@seatlayer/core 0.53.0 → 0.55.0

package/dist/renderer-DySMcKAR.d.cts

@@ -0,0 +1,534 @@
+import { P as Point, A as AccessibilityType, f as SeatCommercialAttributes, a as SeatViewMetadata, g as ResolvedSeatConfidenceEvidence, L as LabelStyle, C as ChartDoc } from './types-DTSG6_Hq.cjs';
+
+interface ExpandedSeat {
+    /** Stable id: `${rowId}:${index}` */
+    id: string;
+    /** Public label: `${rowLabel}-${seatNumber}` */
+    label: string;
+    /** Buyer-facing copy; absent on legacy charts, where `label` is displayed. */
+    displayLabel?: string;
+    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';
+    /** True when the seat has any accessibility accommodation — renderer rings/dims these. */
+    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;
+    /** Calibration/truth inherited from the same scope that supplied `viewUrl`. */
+    viewMeta?: SeatViewMetadata;
+    /** Closest configuration-valid evidence plus its engine-resolved coverage. */
+    confidenceEvidence?: ResolvedSeatConfidenceEvidence;
+    /** 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;
+    /** Buyer tried to add a seat after the active selection cap was reached. */
+    onSelectionLimit?: (maxSelection: number) => void;
+    /** seat is null when the pointer leaves any seat. */
+    onHover?: (seat: ExpandedSeat | null) => void;
+    /** Keyboard focus moved to a seat (arrow-key navigation) — for screen-reader announcements. */
+    onFocusSeat?: (seat: ExpandedSeat | null) => void;
+    /** Called ~1×/sec with the measured frames-per-second. */
+    onFps?: (fps: number) => void;
+    /** Fired when a GA area is clicked (quantity picking is UI-side). */
+    onGAClick?: (areaId: string) => void;
+    /**
+     * Fired when a tap lands on a section outline while seats are NOT the active
+     * rung (i.e. zoomed out, section/zone LOD). The host glides in + shows a
+     * section-summary card instead of trying to select a 4px seat (Slice 5).
+     */
+    onSectionTap?: (sectionId: string) => void;
+    /**
+     * Fired when a seat/deck is tapped in the 3D all-floors stacked overview — the
+     * host drops back to the flat 2D map on that floor ("tap a deck to enter").
+     */
+    onDeckTap?: (floorId: string) => void;
+    /** Fired after any pan/zoom/resize settles — re-anchor screen-space overlays. */
+    onViewChange?: () => void;
+    /**
+     * Organizer manage-mode only (`manageMode` + `marqueeSelect`): fired on
+     * pointer-UP after a rubber-band marquee drag, or a ⌘A/Escape bulk shortcut,
+     * with the FULL current selection (selectable seats only). The host toolbar
+     * reads this to drive bulk block/unblock. Never fires when manageMode is off.
+     */
+    onMarquee?: (seats: ExpandedSeat[]) => void;
+}
+/** Far-zoom level-of-detail rung: whole zones → section blocks → individual seats. */
+type LodRung = 'zones' | 'sections' | 'seats';
+interface RendererOptions extends RendererCallbacks {
+    /**
+     * Internal fixed-output mode used by the free maker's PNG/PDF pipeline.
+     * It disables interaction, ResizeObserver, animation/FPS work and overview
+     * bitmap caching while keeping the ordinary buyer renderer unchanged.
+     */
+    exportMode?: boolean;
+    /** Max seats selectable at once (default 10). */
+    maxSelection?: number;
+    /**
+     * Buyer-surface fit refinement: on containers much taller than the venue's
+     * projection (phones in portrait), zoomToFit may zoom past the strict
+     * width-contain by a bounded amount (≤30%) so the venue is not a thin band
+     * in a dark field. The overflow crops equally on both sides and the buyer
+     * pans freely. Off for the designer and export pipeline, which must always
+     * show the complete chart.
+     */
+    portraitFitCrop?: boolean;
+    /** Only these statuses are clickable (default ['free']). */
+    selectableStatuses?: SeatStatus[];
+    /**
+     * Opt-in host behaviour flag — the renderer's own click/selection logic is
+     * unchanged (it still selects + fires `onSelect` immediately, so the seat
+     * highlights right away). When true, the host (e.g. PublicEventPage) treats
+     * that `onSelect` as a pending candidate and shows a confirm card instead of
+     * pushing straight into the cart; `deselect([seat.id])` on Cancel un-highlights.
+     */
+    confirmSelection?: boolean;
+    /** ISO 4217 currency for on-map prices ("FROM …"); defaults to money.DEFAULT_CURRENCY.
+     *  Locale for grouping/symbol placement comes from the active i18n locale. */
+    currency?: string;
+    /**
+     * Organizer manage surface (SDK SeatManager). Opt-in — enables the manage-mode
+     * gestures (marquee, ⌘A/Escape) and the bulk-selection helpers. Buyer pan /
+     * pinch / tap and every existing code path are byte-identical when this is
+     * false (every manage branch is gated on it). Default false.
+     */
+    manageMode?: boolean;
+    /**
+     * When `manageMode` is on, a mouse/pen primary-button drag at the seats rung
+     * draws a rubber-band marquee that bulk-selects the seats it covers (emitting
+     * `onMarquee` on pointer-up) instead of panning. Touch keeps single-finger
+     * pan (pinch to zoom); a middle-button drag pans with a mouse. Disabled below
+     * the seats rung (zoom in first). No effect unless `manageMode` is also set.
+     */
+    marqueeSelect?: boolean;
+}
+type RenderedLabelHiddenReason = 'below-minimum-size' | 'outside-viewport' | 'dimmed-or-unavailable' | 'clutter-or-fit' | 'renderer-hidden';
+/** Browser-renderer evidence used by visual QA and catalog release gates. */
+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;
+    status: SeatStatus;
+    selected: boolean;
+    visible: boolean;
+    renderedFontPx: number;
+    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;
+        directWidthPx: number;
+        directHeightPx: number;
+        effectiveMinimumPx: number;
+    };
+    /** Centre of the painted unit, even when its text is intentionally hidden. */
+    screenCenter: {
+        x: number;
+        y: number;
+    };
+    screenBox?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    hiddenReason?: RenderedLabelHiddenReason;
+}
+interface RenderedHierarchyLabelEvidence {
+    id: string;
+    kind: 'section' | 'zone';
+    role: 'name' | 'availability' | 'price';
+    label: string;
+    visible: boolean;
+    renderedFontPx: number;
+    opacity: number;
+    fill: string;
+    ink: string;
+    /** Independent geometric containment check for section-owned text. */
+    fitsContainer?: boolean;
+    screenBox?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+}
+interface RenderedFreeTextEvidence {
+    objectId: string;
+    kind: 'free-text' | 'stage' | 'table' | 'decor' | 'ga-label' | 'ga-capacity';
+    text: string;
+    visible: boolean;
+    renderedFontPx: number;
+    ink: string;
+    background: string;
+    opacity: number;
+    screenBox?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    hiddenReason?: 'below-minimum-size' | 'outside-viewport' | 'renderer-hidden';
+}
+interface RenderedRowLabelEvidence {
+    text: string;
+    visible: boolean;
+    renderedFontPx: number;
+    ink: string;
+    screenBox?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+}
+interface RenderedGAAreaEvidence {
+    areaId: string;
+    label: string;
+    capacity: number;
+    categoryKey: string;
+    /** Owning logical section when the rendered GA surface is section-contained. */
+    sectionId?: string;
+    visible: boolean;
+    interactive: boolean;
+    opacity: number;
+    fill: string;
+    effectiveBackground: string;
+    screenBox?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+}
+interface RendererQualityEvidence {
+    viewport: {
+        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;
+    minimumVisibleLabelPx: number;
+    totalLabelledBookableUnits: number;
+    visibleLabels: number;
+    hiddenLabels: number;
+    /** Seats/table-seats/booths plus the full GA capacity. */
+    totalBookableUnits: number;
+    selectionRingSeatIds: string[];
+    selectionRingColor: string;
+    focusedSectionId: string | null;
+    focusBackdropVisible: boolean;
+    categoryFilterKeys: string[] | null;
+    /** Exact scene-graph proof for the clean section-first overview contract. */
+    overviewStyle: {
+        visibleSectionShells: number;
+        categoryPaintedSectionShells: number;
+        visibleCategoryDetailOutlines: number;
+        visibleSectionRowHints: number;
+        visibleSectionAvailabilityLabels: number;
+        visibleSectionGADetails: number;
+    };
+    labels: RenderedBookableLabelEvidence[];
+    gaAreas: RenderedGAAreaEvidence[];
+    hierarchyLabels: RenderedHierarchyLabelEvidence[];
+    freeTextLabels: RenderedFreeTextEvidence[];
+    rowLabels: RenderedRowLabelEvidence[];
+}
+interface ISeatmapRenderer {
+    /** Replace the chart. Resets selection and statuses, zooms to fit.
+     *  `opts.floorId` picks which floor to render on a multi-floor chart (Batch 5). */
+    setChart(doc: ChartDoc, opts?: {
+        floorId?: string;
+    }): void;
+    /** Bulk status update; re-renders affected seats only. */
+    setStatus(seatIds: string[], status: SeatStatus): void;
+    /** Organizer event-category override: repaint existing inventory ids without
+     * rebuilding geometry, camera, or selection. Unknown ids/keys are ignored. */
+    setSeatCategories?(assignments: Record<string, string>): void;
+    /**
+     * Mark the active buyer's own held seats. They remain server-status `held`,
+     * but render with the buyer selection treatment instead of the anonymous
+     * unavailable treatment used for another buyer's hold.
+     */
+    setOwnedHold?(seatIds: string[] | null): void;
+    /**
+     * Mark one selected seat as the buyer's pending confirmation candidate.
+     * The candidate receives a strong focus halo while unrelated seats recede;
+     * pass null after Select/Cancel. This is visual only and never mutates the
+     * renderer selection.
+     */
+    setSelectionFocus?(seatId: string | null): void;
+    /**
+     * SYNCHRONOUS repaint that bypasses requestAnimationFrame. Konva's batchDraw()
+     * (used by setStatus and friends) schedules the actual paint on the next rAF
+     * tick, which Chrome throttles/pauses on hidden, backgrounded, or occluded
+     * tabs — so a seat-status delta updates the scene graph but the pixels never
+     * change until the tab is foregrounded again. forceDraw() paints the affected
+     * layers immediately (Layer.draw() is synchronous) and flushes any pending
+     * cache-debounce, so a caller (visibilitychange catch-up, or an opted-in
+     * always-live board) can guarantee the canvas reflects current state
+     * regardless of tab visibility. No-op difference in the foreground.
+     */
+    forceDraw(): void;
+    getStatus(seatId: string): SeatStatus;
+    getSelection(): ExpandedSeat[];
+    clearSelection(): void;
+    /** Update the buyer selection cap without rebuilding the chart or camera. */
+    setMaxSelection?(maxSelection: number): void;
+    /**
+     * Programmatically restore free seats (for example an Undo action). Added
+     * seats respect the active cap and do not reopen a confirmation popover.
+     */
+    select?(seatIds: string[]): ExpandedSeat[];
+    /**
+     * Dynamically update organizer-only interaction without rebuilding the
+     * renderer. No buyer surface calls this; every behavior remains gated by
+     * `manageMode` exactly as it is at construction time.
+     */
+    setManageInteraction?(options: {
+        manageMode: boolean;
+        marqueeSelect: boolean;
+        selectableStatuses: SeatStatus[];
+        maxSelection?: number;
+    }): void;
+    /** Organizer-only section heat overlay. Values are normalized 0..1. */
+    setSectionHeat?(scores: Record<string, number> | null): void;
+    /**
+     * Manage-mode bulk selection helpers (no-op / empty unless `manageMode`).
+     * They select the matching SELECTABLE seats (respecting `selectableStatuses`
+     * + closed sections), union with the current selection, and return the seats
+     * they added — the SDK SeatManager expands category/row/section picks to
+     * labels and drives one batched block/unblock from them.
+     */
+    selectAllSelectable?(): ExpandedSeat[];
+    selectByLabels?(labels: string[]): ExpandedSeat[];
+    /** Exact-render QA only: select one server-chosen unit without label ambiguity. */
+    setEvidenceSelection?(seatId: string): boolean;
+    /** Selectable seats belonging to a section OR zone id (no selection side-effect). */
+    getSelectableInSection?(sectionId: string): ExpandedSeat[];
+    /** Programmatic deselect of specific seats (e.g. chip × in the cart). */
+    deselect(seatIds: string[]): void;
+    /**
+     * Brief attention pulse on a seat (a ring that expands + fades once) — used to
+     * signal live activity, e.g. a seat "just taken" by another buyer via a WS
+     * delta. Purely visual; no state change. `color` overrides the default.
+     */
+    flashSeat(seatId: string, color?: string): void;
+    /**
+     * Brief organizer attention pulse around a whole section. This is a visual
+     * overlay only: it never changes section geometry, hit targets, selection, or
+     * the active camera. Useful for grouped realtime operations at venue overview.
+     */
+    flashSection?(sectionId: string, color?: string): void;
+    zoomToFit(): void;
+    /** Refit the active section when focused; otherwise frame the current floor/view. */
+    refitCurrentView?(): void;
+    /** Zoom in one step about the viewport center, clamped to the usual zoom bounds. */
+    zoomIn(): void;
+    /** Zoom out one step about the viewport center, clamped to the usual zoom bounds. */
+    zoomOut(): void;
+    /** Individually status-managed seats/table-seats/booths; excludes GA capacity. */
+    seatCount(): number;
+    /** Seats/table-seats/booths plus the full capacity of rendered GA areas. */
+    bookableCount(): number;
+    /**
+     * Maps a chart-space point (or a seat, by its x/y) to container-relative
+     * screen pixels, using the current stage scale/position. Lets host UI anchor
+     * DOM overlays (confirm card, tooltip) over a live seat and re-anchor them
+     * on `onViewChange`.
+     */
+    worldToScreen(point: Point): {
+        x: number;
+        y: number;
+    };
+    /** When on, dim non-accessible free seats so accessible seats stand out. */
+    setAccessibleFilter(on: boolean): void;
+    /**
+     * Dim free seats that lack ANY of these accessibility types. `null` clears the
+     * filter; `[]` means "any accessible seat" (same as setAccessibleFilter(true)).
+     */
+    setAccessibilityFilter(types: AccessibilityType[] | null): void;
+    /** Legend hover-highlight: dim free seats of other categories (null clears). */
+    setCategoryHighlight?(key: string | null): void;
+    /** Price-band filter (F4): dim free seats whose category is NOT in `keys`
+     *  (null clears). The widget resolves which categories fall in the band. */
+    setCategoryFilter?(keys: string[] | null): void;
+    /** Smoothly frame the currently available seats in these categories. `null`
+     *  returns to the full chart. Used after an explicit buyer price-filter action. */
+    focusCategories?(keys: string[] | null): void;
+    /** Dim the seats of these section/zone ids (organizer manager: held-back inventory). */
+    setDimmedSections?(ids: string[] | null): void;
+    /**
+     * Phase 2 event-level section states: mark these section/zone ids `closed` —
+     * flat grey block, seats greyed + not pickable, section stays rendered.
+     * `null`/empty clears. (Distinct from the buyer's applyHidden seat-strip.)
+     */
+    setClosedSections?(ids: string[] | null): void;
+    /**
+     * AXS section-focus: dim + desaturate every other section, draw a calm backdrop
+     * behind this section, and glide the camera to frame it. Seat-picking is gated
+     * until seats are large enough on screen (≥ LABEL_SCALE). Slice 5 / Phase 2 §4.
+     */
+    focusSection?(id: string): void;
+    /** Clear an AXS section focus (restore full-bowl brightness + drop backdrop). */
+    clearSectionFocus?(): void;
+    /** The currently AXS-focused section id, or null. */
+    getFocusedSection?(): string | null;
+    /** World-space rect currently visible in the viewport (minimap viewport frame). */
+    getVisibleWorldRect?(): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    /** Axis-aligned world bounds of all seats + section outlines (minimap frame). */
+    getWorldBounds?(): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    /** Current rendered (not raw-source) geometry for an interactive overview.
+     * Multi-floor overview transforms are already applied to these coordinates. */
+    getMinimapSnapshot?(): RendererMinimapSnapshot;
+    /** Pan without changing zoom so `point` becomes the viewport centre. */
+    panToWorld?(point: Point): void;
+    /**
+     * Colorblind-safe mode: category hues switch to an Okabe-Ito palette and
+     * booked seats render hollow (a non-color cue), so seat state never relies
+     * on hue alone. Off (the default) renders exactly as before.
+     */
+    setColorblindSafe?(on: boolean): void;
+    /**
+     * Switch the projection. `'flat'` = normal top-down; `'isometric'` = the
+     * 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: RendererViewMode): void;
+    /** Current projection (defaults to 'flat' when unimplemented). */
+    getViewMode?(): RendererViewMode;
+    /** Multi-floor (Batch 5): switch the shown floor; list floors; read the active id. */
+    setActiveFloor?(floorId: string): void;
+    getFloors?(): {
+        id: string;
+        name: string;
+    }[];
+    getActiveFloorId?(): string;
+    /** Render all floors stacked (3D overview) vs the active floor. No-op single-floor. */
+    setStacked?(on: boolean): void;
+    isStacked?(): boolean;
+    /** Render every floor in its authored 2D coordinates so the buyer can choose a level. */
+    setFloorOverview?(on: boolean): void;
+    isFloorOverview?(): boolean;
+    /**
+     * Section id whose outline contains a container-relative screen point (or null).
+     * Feeds the far-zoom "tap a section to zoom in" flow (Slice 5).
+     */
+    sectionAt?(clientPoint: Point): string | null;
+    /** Seat ids belonging to a section — for the section-summary card (Slice 5). */
+    sectionMembers?(id: string): string[];
+    /**
+     * Smoothly glide (pan+zoom) the camera to frame a section (by id) or a world-
+     * space bounds rect over a calm easeInOutCubic glide. `prefers-reduced-motion` snaps.
+     * A pointer-down (grab/pan) cancels an in-flight glide. Slice 5 "glide in".
+     */
+    focusRegion?(target: string | {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }, opts?: {
+        animate?: boolean;
+        minScale?: number;
+        durationMs?: number;
+    }): void;
+    /** Current LOD rung derived from zoom (for the ZONES/SECTIONS/SEATS pill). */
+    getRung?(): LodRung;
+    /** Jump the camera to a rung's zoom band, centred on the chart (glided). */
+    setRung?(rung: LodRung): void;
+    /** Read actual browser-rendered label visibility, size, fill, ink and state.
+     *  Pure diagnostic: it never changes chart or renderer state. */
+    getRenderedQualityEvidence(): RendererQualityEvidence;
+    destroy(): void;
+}
+interface RendererMinimapSection {
+    id: string;
+    label: string;
+    outline: Point[];
+    floorId?: string;
+    state: 'selected' | 'available' | 'inactive';
+    active: boolean;
+}
+interface RendererMinimapSeat {
+    x: number;
+    y: number;
+    categoryKey: string;
+    state: 'selected' | 'available' | 'inactive';
+}
+interface RendererMinimapSnapshot {
+    sections: RendererMinimapSection[];
+    seats: RendererMinimapSeat[];
+}
+/** localStorage key the Designer writes and the Picker reads. */
+declare const CHART_STORAGE_KEY = "seatmap.chart";
+
+export { CHART_STORAGE_KEY as C, type ExpandedSeat as E, type ISeatmapRenderer as I, type LodRung as L, type RendererQualityEvidence as R, type SeatStatus as S, type RenderedFreeTextEvidence as a, type RendererOptions as b, type RendererViewMode as c, type RendererMinimapSnapshot as d, type RendererCallbacks as e, type RenderedBookableLabelEvidence as f, type RenderedGAAreaEvidence as g, type RenderedHierarchyLabelEvidence as h, type RenderedLabelHiddenReason as i, type RenderedRowLabelEvidence as j, type RendererMinimapSeat as k, type RendererMinimapSection as l };

package/dist/sections-DIzgtDjF.d.ts

@@ -0,0 +1,123 @@
+import { d as SectionObject, C as ChartDoc } from './types-DTSG6_Hq.js';
+
+/**
+ * Real-world scale primitives — the ONE place the app fixes chart-unit ↔ metre ↔
+ * renderer-world scale, and the section 3D-geometry resolver that rides on it.
+ *
+ * Everything that converts between chart units, metres, and renderer "world"
+ * units derives from {@link METRES_PER_CHART_UNIT}. Renderer world units and
+ * chart units are 1:1, so metres → world is exactly {@link CHART_UNITS_PER_METRE}
+ * (the single m→world conversion constant Phase B consumers use).
+ *
+ * This is a leaf module (types only) so both `layout.ts` and `sections.ts` can
+ * import it without the two forming an import cycle.
+ */
+
+/**
+ * Metres of front-edge height one elevation tier represents. Chosen (not guessed)
+ * so `elevation × TIER_HEIGHT_M` metres, scaled back through
+ * {@link CHART_UNITS_PER_METRE}, equals the legacy `elevation × LIFT_PER_STEP`
+ * world lift exactly — an un-authored chart stays pixel-identical. ≈ 1.329 m/tier.
+ */
+declare const TIER_HEIGHT_M: number;
+/**
+ * Resolve a section's real 3D geometry, applying the legacy-elevation fallback so
+ * old charts and new charts share ONE code path. Every consumer (iso lift, 360°
+ * eye-height, author lint, any 2D depth cue) must call this and never read the raw
+ * {@link SectionObject.height}/{@link SectionObject.rake} fields — that is what
+ * keeps un-authored charts rendering identically to today.
+ *
+ * - `height`: authored absolute metres if present, else owning-floor base height
+ *   plus `elevation × TIER_HEIGHT_M`.
+ * - `rake`: authored degrees if present, else 0 (flat).
+ *
+ * Malformed values are bounded here as a last defensive barrier. Structural
+ * validation still reports them so drafts can be repaired instead of silently
+ * persisting a renderer-only interpretation.
+ *
+ * Pure — no document mutation, no side effects.
+ */
+interface SectionGeometryContext {
+    /** Absolute physical height of the owning floor above the venue datum. */
+    floorBaseHeightM?: number;
+}
+declare function sectionGeometry(section: Pick<SectionObject, 'elevation' | 'height' | 'rake'>, context?: SectionGeometryContext): {
+    height: number;
+    rake: number;
+};
+
+/**
+ * Section membership + hide/show resolution (Batch 3.3).
+ *
+ * A `SectionObject` is a polygon drawn over existing seat objects; an object
+ * "belongs" to a section when its visual centre (`objectCenter`) falls inside
+ * the section outline, first section in doc order winning. This is the same
+ * spatial notion `objectCenter`'s doc-comment describes, resolved once here so
+ * BOTH the event manager (Sections tab counts) and the buyer picker (omit
+ * hidden seats) agree on which seats live in which section.
+ *
+ * Hiding is per-EVENT (the EventDO holds the hidden id set), not a chart edit —
+ * so a republish of the chart never disturbs it. A hidden id may be a section
+ * id, a zone id (hides every section in the zone), or `UNGROUPED_ID` (the
+ * catch-all bucket of seat objects that sit in no section).
+ */
+
+/** Synthetic section id for seat objects that fall in no drawn section. */
+declare const UNGROUPED_ID = "__ungrouped__";
+/**
+ * A per section/zone availability window (Batch 3.4). Wire-compatible with the
+ * EventDO's own `AvailabilityRule`. Absence of a rule for an id = on sale.
+ *   'hidden'    — manual: hidden until the organizer reveals it (3.3).
+ *   'timed'     — hidden until `revealAt` (epoch ms), then auto-reveals.
+ *   'threshold' — auto-reveals once the on-sale inventory is `thresholdPct`% sold.
+ *   'closed'    — visible to buyers but not purchasable (rendered flat grey);
+ *                 unlike 'hidden', the seats stay on the map, just off sale.
+ * `labels` are the seat labels the id governs, so a threshold's denominator can
+ * exclude still-hidden seats.
+ */
+interface AvailabilityRule {
+    mode: 'hidden' | 'timed' | 'threshold' | 'closed';
+    revealAt?: number;
+    thresholdPct?: number;
+    labels?: string[];
+}
+interface SectionNode {
+    /** Section id (a `SectionObject.id`, or `UNGROUPED_ID`). */
+    id: string;
+    label: string;
+    /** Zone id this section points at (`SectionObject.zone`), if any. */
+    zone?: string;
+    /** Total seats across the member objects. */
+    seatCount: number;
+    /** Ids of the seat-bearing objects that belong to this section. */
+    objectIds: string[];
+    /** Seat labels across the member objects (for availability-rule denominators). */
+    seatLabels: string[];
+}
+/**
+ * Resolve section membership for a chart. Returns one node per drawn section
+ * (doc order), a synthetic "Ungrouped" node for loose seat objects (null when
+ * every seat sits in a section), and the object→section id map.
+ */
+declare function computeSections(doc: ChartDoc): {
+    sections: SectionNode[];
+    ungrouped: SectionNode | null;
+    /** seat-object id → owning section id (or `UNGROUPED_ID`). */
+    objectToSection: Map<string, string>;
+};
+/** Is a drawn section hidden under `hidden` — directly, or via its zone? */
+declare function isSectionHidden(s: SectionObject, hidden: ReadonlySet<string>): boolean;
+/**
+ * The set of seat-object ids to omit from the buyer view for a given hidden id
+ * set. An object is hidden when its owning section is hidden (directly or via
+ * zone), or it is ungrouped and the catch-all bucket is hidden.
+ */
+declare function hiddenObjectIds(doc: ChartDoc, hidden: ReadonlySet<string>): Set<string>;
+/**
+ * A copy of the doc with hidden sections' member objects removed, plus the
+ * hidden section overlays themselves (so no empty block renders). Returns the
+ * SAME reference when nothing is hidden — callers can skip a re-render on `===`.
+ */
+declare function applyHidden(doc: ChartDoc, hidden: ReadonlySet<string>): ChartDoc;
+
+export { type AvailabilityRule as A, type SectionNode as S, TIER_HEIGHT_M as T, UNGROUPED_ID as U, applyHidden as a, computeSections as c, hiddenObjectIds as h, isSectionHidden as i, sectionGeometry as s };