@seatlayer/core 0.53.0 → 0.55.0

package/dist/labeling-BmCzW50y.d.ts

@@ -0,0 +1,90 @@
+import { i as SectionOutlinePath, P as Point, j as SectionPathSegment } from './types-DTSG6_Hq.js';
+
+declare function sectionPathSegmentEnd(segment: SectionPathSegment): Point;
+/** Validate finite, continuous closed-path geometry without trusting renderer
+ * behaviour. Arc endpoints must lie on their declared circle. */
+declare function validSectionOutlinePath(path: SectionOutlinePath): boolean;
+/** Deterministic polygon sample used by validation, hit testing, diff, and old
+ * clients. The returned loop omits the duplicate closing point. */
+declare function sampleSectionOutlinePath(path: SectionOutlinePath, maxStep?: number): Point[];
+declare function translateSectionOutlinePath(path: SectionOutlinePath, dx: number, dy: number): SectionOutlinePath;
+/** Apply a similarity transform. Callers provide the point transform and the
+ * absolute radius scale; reflections toggle arc direction. */
+declare function transformSectionOutlinePath(path: SectionOutlinePath, transform: (point: Point) => Point, radiusScale?: number, reflected?: boolean): SectionOutlinePath;
+/** Default corner-smoothing strength applied automatically when a hand-clicked
+ * polygon section is closed. Wide, gently-angled corners round; sharp structural
+ * corners stay crisp, so a rectangle drawn as a polygon is left untouched. */
+declare const DEFAULT_SECTION_CORNER_SMOOTHING = 45;
+/**
+ * Build a smooth closed {@link SectionOutlinePath} by rounding the wide corners
+ * of a hand-clicked polygon. The polygon stays authoritative — this is a purely
+ * additive rendered curve. Returns `null` when nothing qualifies (strength 0, a
+ * degenerate polygon, or no corner wide enough), letting the caller keep the raw
+ * straight polygon. Deterministic: same input always yields the same path.
+ */
+declare function sectionCornerSmoothingPath(polygon: Point[], strength: number, options?: {
+    wideAngleThresholdDeg?: number;
+}): SectionOutlinePath | null;
+/**
+ * Largest bow, as a fraction of the edge's own length, at curvature ±100. Half
+ * the chord reads as a strong arc while staying well short of a shape that folds
+ * back on itself.
+ */
+declare const MAX_EDGE_SAGITTA_RATIO = 0.5;
+interface SectionOutlineDerivation {
+    /** 0–100. Rounds corners wider than the threshold. */
+    cornerSmoothing?: number;
+    /**
+     * One entry per edge of the clicked polygon, -100..100, 0 = straight. Edge `i`
+     * runs from vertex `i` to vertex `i+1`. Positive bows to the LEFT of that
+     * direction; the sign is relative to edge direction, never to world axes, so
+     * curvature survives rotate / flip / mirror untouched.
+     */
+    edgeCurvature?: readonly number[];
+    wideAngleThresholdDeg?: number;
+}
+/**
+ * Derive the rendered outline from the clicked polygon plus its coordinate-free
+ * shaping (corner smoothing and per-edge curvature).
+ *
+ * The polygon stays authoritative — this is purely a rendered curve, so zeroing
+ * the shaping restores the exact clicked shape. Deterministic: same input always
+ * yields the same path. Returns `null` when there is nothing to draw beyond the
+ * raw polygon, letting the caller keep the straight outline.
+ */
+declare function sectionOutlinePathFrom(polygon: Point[], derivation: SectionOutlineDerivation): SectionOutlinePath | null;
+/** Reverse a closed path without changing its painted boundary. */
+declare function reverseSectionOutlinePath(path: SectionOutlinePath): SectionOutlinePath;
+
+/**
+ * Pure row/seat labeling helpers used by the designer's "relabel" tools
+ * (e.g. bulk-renumber rows A, B, C… or 1, 2, 3…). No dependencies.
+ */
+interface RelabelOptions {
+    scheme: 'letters' | 'numbers';
+    /** 1-based start: letters 1=A; numbers 1=1. */
+    startAt: number;
+    /** Letters only: skip I and O (common theatre convention). */
+    skipAmbiguous?: boolean;
+    /** Apply labels in reverse order over the given array. */
+    reverse?: boolean;
+}
+/**
+ * Bijective base-N conversion: 0 -> first letter, N -> second letter's
+ * first repeat cycle (e.g. base26: 25 -> 'Z', 26 -> 'AA').
+ */
+declare function toBijectiveBase(index: number, alphabet: string): string;
+declare function indexLabel(i: number, opts: RelabelOptions): string;
+/**
+ * Alphabetic label for a 1-based value (1 -> 'A', 26 -> 'Z', 27 -> 'AA').
+ * Uppercase by default; `lower` gives the a,b,c… variant. Values ≤ 0 clamp to 'A'.
+ */
+declare function toLetters(value: number, lower?: boolean): string;
+/** Uppercase Roman numeral for a positive integer (1 -> 'I', 4 -> 'IV', 9 -> 'IX').
+ *  Non-positive / non-finite inputs fall back to their decimal string. */
+declare function toRoman(value: number): string;
+declare function relabelRows<T extends {
+    label: string;
+}>(rows: T[], opts: RelabelOptions): T[];
+
+export { DEFAULT_SECTION_CORNER_SMOOTHING as D, MAX_EDGE_SAGITTA_RATIO as M, type RelabelOptions as R, type SectionOutlineDerivation as S, reverseSectionOutlinePath as a, sectionCornerSmoothingPath as b, sectionOutlinePathFrom as c, sectionPathSegmentEnd as d, toLetters as e, toRoman as f, transformSectionOutlinePath as g, translateSectionOutlinePath as h, indexLabel as i, relabelRows as r, sampleSectionOutlinePath as s, toBijectiveBase as t, validSectionOutlinePath as v };

package/dist/labeling-VfJBEOn0.d.cts

@@ -0,0 +1,90 @@
+import { i as SectionOutlinePath, P as Point, j as SectionPathSegment } from './types-DTSG6_Hq.cjs';
+
+declare function sectionPathSegmentEnd(segment: SectionPathSegment): Point;
+/** Validate finite, continuous closed-path geometry without trusting renderer
+ * behaviour. Arc endpoints must lie on their declared circle. */
+declare function validSectionOutlinePath(path: SectionOutlinePath): boolean;
+/** Deterministic polygon sample used by validation, hit testing, diff, and old
+ * clients. The returned loop omits the duplicate closing point. */
+declare function sampleSectionOutlinePath(path: SectionOutlinePath, maxStep?: number): Point[];
+declare function translateSectionOutlinePath(path: SectionOutlinePath, dx: number, dy: number): SectionOutlinePath;
+/** Apply a similarity transform. Callers provide the point transform and the
+ * absolute radius scale; reflections toggle arc direction. */
+declare function transformSectionOutlinePath(path: SectionOutlinePath, transform: (point: Point) => Point, radiusScale?: number, reflected?: boolean): SectionOutlinePath;
+/** Default corner-smoothing strength applied automatically when a hand-clicked
+ * polygon section is closed. Wide, gently-angled corners round; sharp structural
+ * corners stay crisp, so a rectangle drawn as a polygon is left untouched. */
+declare const DEFAULT_SECTION_CORNER_SMOOTHING = 45;
+/**
+ * Build a smooth closed {@link SectionOutlinePath} by rounding the wide corners
+ * of a hand-clicked polygon. The polygon stays authoritative — this is a purely
+ * additive rendered curve. Returns `null` when nothing qualifies (strength 0, a
+ * degenerate polygon, or no corner wide enough), letting the caller keep the raw
+ * straight polygon. Deterministic: same input always yields the same path.
+ */
+declare function sectionCornerSmoothingPath(polygon: Point[], strength: number, options?: {
+    wideAngleThresholdDeg?: number;
+}): SectionOutlinePath | null;
+/**
+ * Largest bow, as a fraction of the edge's own length, at curvature ±100. Half
+ * the chord reads as a strong arc while staying well short of a shape that folds
+ * back on itself.
+ */
+declare const MAX_EDGE_SAGITTA_RATIO = 0.5;
+interface SectionOutlineDerivation {
+    /** 0–100. Rounds corners wider than the threshold. */
+    cornerSmoothing?: number;
+    /**
+     * One entry per edge of the clicked polygon, -100..100, 0 = straight. Edge `i`
+     * runs from vertex `i` to vertex `i+1`. Positive bows to the LEFT of that
+     * direction; the sign is relative to edge direction, never to world axes, so
+     * curvature survives rotate / flip / mirror untouched.
+     */
+    edgeCurvature?: readonly number[];
+    wideAngleThresholdDeg?: number;
+}
+/**
+ * Derive the rendered outline from the clicked polygon plus its coordinate-free
+ * shaping (corner smoothing and per-edge curvature).
+ *
+ * The polygon stays authoritative — this is purely a rendered curve, so zeroing
+ * the shaping restores the exact clicked shape. Deterministic: same input always
+ * yields the same path. Returns `null` when there is nothing to draw beyond the
+ * raw polygon, letting the caller keep the straight outline.
+ */
+declare function sectionOutlinePathFrom(polygon: Point[], derivation: SectionOutlineDerivation): SectionOutlinePath | null;
+/** Reverse a closed path without changing its painted boundary. */
+declare function reverseSectionOutlinePath(path: SectionOutlinePath): SectionOutlinePath;
+
+/**
+ * Pure row/seat labeling helpers used by the designer's "relabel" tools
+ * (e.g. bulk-renumber rows A, B, C… or 1, 2, 3…). No dependencies.
+ */
+interface RelabelOptions {
+    scheme: 'letters' | 'numbers';
+    /** 1-based start: letters 1=A; numbers 1=1. */
+    startAt: number;
+    /** Letters only: skip I and O (common theatre convention). */
+    skipAmbiguous?: boolean;
+    /** Apply labels in reverse order over the given array. */
+    reverse?: boolean;
+}
+/**
+ * Bijective base-N conversion: 0 -> first letter, N -> second letter's
+ * first repeat cycle (e.g. base26: 25 -> 'Z', 26 -> 'AA').
+ */
+declare function toBijectiveBase(index: number, alphabet: string): string;
+declare function indexLabel(i: number, opts: RelabelOptions): string;
+/**
+ * Alphabetic label for a 1-based value (1 -> 'A', 26 -> 'Z', 27 -> 'AA').
+ * Uppercase by default; `lower` gives the a,b,c… variant. Values ≤ 0 clamp to 'A'.
+ */
+declare function toLetters(value: number, lower?: boolean): string;
+/** Uppercase Roman numeral for a positive integer (1 -> 'I', 4 -> 'IV', 9 -> 'IX').
+ *  Non-positive / non-finite inputs fall back to their decimal string. */
+declare function toRoman(value: number): string;
+declare function relabelRows<T extends {
+    label: string;
+}>(rows: T[], opts: RelabelOptions): T[];
+
+export { DEFAULT_SECTION_CORNER_SMOOTHING as D, MAX_EDGE_SAGITTA_RATIO as M, type RelabelOptions as R, type SectionOutlineDerivation as S, reverseSectionOutlinePath as a, sectionCornerSmoothingPath as b, sectionOutlinePathFrom as c, sectionPathSegmentEnd as d, toLetters as e, toRoman as f, transformSectionOutlinePath as g, translateSectionOutlinePath as h, indexLabel as i, relabelRows as r, sampleSectionOutlinePath as s, toBijectiveBase as t, validSectionOutlinePath as v };

package/dist/layout-ClQkmixY.d.ts

@@ -0,0 +1,181 @@
+import { A as AccessibilityType, S as SeatOverride, R as RowObject, a as SeatViewMetadata, L as LabelStyle, b as RectTableSide, C as ChartDoc, c as ChartObject, B as BoothObject, T as TableObject, P as Point, F as Floor, d as SectionObject, e as RectTableSeatCounts } from './types-DTSG6_Hq.js';
+import { S as SegmentedRowPlacement } from './segmentedRowModel-COXw4GCh.js';
+import { E as ExpandedSeat } from './renderer-B_g-W_QB.js';
+
+/**
+ * Pure geometry helpers — no Konva, no DOM. Turns the parametric chart
+ * document into concrete seat coordinates and computes bounding boxes.
+ */
+
+/**
+ * Expand a parametric row into seat positions.
+ *
+ * Straight (curve === 0): seat i sits at local (i·spacing, 0).
+ *
+ * Curved: seats lie on a circular arc. Per-seat angular step is
+ * `curve/(seatCount-1)`; radius is derived so the chord between neighbours
+ * equals seatSpacing → radius = spacing / (2·sin(step/2)). Seat 0 sits at the
+ * bottom of the arc (local origin) with the circle centre directly above it at
+ * (0,-radius); increasing index sweeps toward +x while the ends rise toward -y,
+ * i.e. positive curve is concave toward -y (a row wrapping a stage above it).
+ * Local points are then rotated by `rotation` and translated to `origin`.
+ *
+ * Numbering (labels only, never geometry): `seatNumbering.direction === 'rtl'`
+ * numbers from the far physical end; `step === 2` produces odd/even numbering
+ * (start at 1 → 1,3,5…; start at 2 → 2,4,6…).
+ */
+/** 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
+ * but a skipped slot is flagged, not omitted.
+ */
+interface RowSeatSlot {
+    index: number;
+    x: number;
+    y: number;
+    label: string;
+    displayLabel: string;
+    categoryKey: string;
+    skipped: boolean;
+    accessible: boolean;
+    accessibility: AccessibilityType[];
+    wheelchairSpaceType?: SeatOverride['wheelchairSpaceType'];
+    commercial?: RowObject['commercial'];
+    viewUrl?: string;
+    viewMeta?: SeatViewMetadata;
+    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;
+}
+/**
+ * Seat slots for one physical row.
+ *
+ * `placement` makes the slots read as part of a logical segmented row: labels
+ * continue across components (`A-8`, not a second `A-1`) using the logical row's
+ * numbering scheme and total seat count.
+ */
+declare function expandRowSlots(row: RowObject, placement?: SegmentedRowPlacement): RowSeatSlot[];
+declare function expandRow(row: RowObject): ExpandedSeat[];
+/**
+ * Expand a table into its perimeter seats.
+ *
+ * Round: seats spread evenly on a circle of radius `radius + 16`, the first at
+ * angle `rotation` (degrees, clockwise from +x). Rect: seats line the top and
+ * 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[];
+/** Ray-cast point-in-polygon test — odd crossings ⇒ inside. */
+declare function pointInPolygon(p: Point, poly: Point[]): boolean;
+declare function pointInPolygonWithHoles(p: Point, outer: Point[], holes: Point[][] | undefined): boolean;
+/**
+ * Stable interior label anchor: the centre of the largest circle that fits in
+ * the polygon (holes excluded).
+ *
+ * This used to return the average-of-vertices centroid whenever that happened
+ * to be inside, and only fell back to a coarse 24×24 grid search when it was
+ * not. "Inside" is a much weaker property than "has room": on a traced arena
+ * the outer arc of a wedge carries dozens of sampled vertices and the radial
+ * edges carry two, so the average is dragged onto the arc and the label pill —
+ * far wider than a point — straddled the boundary into the next section.
+ * Measured on the 36-section traced arena corpus, 15 of 36 anchors had under
+ * 75% of the clearance actually available, some as little as 43%.
+ *
+ * `polygonInscribedAnchor` is deterministic and coordinate-free, so callers may
+ * memoize it on geometry alone.
+ */
+declare function polygonLabelPoint(outer: Point[], holes: Point[][] | undefined): Point;
+/**
+ * Visual centre of any object — used for spatial section membership and for
+ * rotating an object about its centre. Rows: centroid of expanded seats (or
+ * origin when empty); tables/booths: centre; GA/section: polygon centroid;
+ * 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
+ * to reason about floors goes through this so single-floor charts stay untouched.
+ */
+declare function floorsOf(doc: ChartDoc): Floor[];
+/** Objects of one floor by id (defaults to the first floor). */
+declare function floorObjects(doc: ChartDoc, floorId?: string): ChartObject[];
+/** Every object across ALL floors — the whole venue (single-floor = `doc.objects`). */
+declare function allObjects(doc: ChartDoc): ChartObject[];
+/** A copy of an object translated by (dx, dy) — every coordinate field shifted. */
+declare function translateObject(o: ChartObject, dx: number, dy: number): ChartObject;
+/**
+ * Multi-floor 3D stack (Batch 5): flatten every floor into ONE doc with floor `i`
+ * lifted by `i * spread` in −y, so the isometric view shows the floors as stacked
+ * decks (ground at the bottom). Returns a single-floor doc (no `floors`). Meant
+ * only for the 3D overview render — 2D still shows one floor via `floorObjects`.
+ */
+declare function stackFloors(doc: ChartDoc, spread?: number): ChartDoc;
+/**
+ * Build the buyer-facing 2D overview of a multi-floor chart.
+ *
+ * Floors commonly reuse the same drawing origin (a balcony is authored over
+ * the stalls it overlooks). Flattening those source coordinates makes a valid
+ * import look corrupt because every level is painted on top of every other
+ * level. This projection packs complete floors into a compact, content-aware
+ * grid. Each floor receives one rigid translation: no seat, row, section,
+ * annotation, gap, or rotation changes, and the canonical document is never
+ * mutated.
+ */
+declare function layoutFloorOverview(doc: ChartDoc): ChartDoc;
+/**
+ * Rigid per-floor translations used by the buyer's complete-venue overview.
+ *
+ * Kept as a pure public helper so 2D and 3D can present the same non-overlapping
+ * level arrangement without either renderer rewriting the authored chart. A
+ * zero translation is returned for a single-floor document.
+ */
+declare function floorOverviewTranslations(doc: ChartDoc): Point[];
+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;
+    /** Resolve per-seat 3D eye heights (default true). Two-dimensional consumers
+     * such as thumbnails can disable this expensive stand-structure pass. */
+    resolveEyeHeights?: boolean;
+}
+/** 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;
+    y: number;
+    width: number;
+    height: number;
+};
+
+export { type ExpandChartOptions as E, type RowSeatSlot as R, type TableSeatSlot as T, allObjects as a, expandChart as b, chartBounds as c, expandRow as d, expandBooth as e, expandRowSlots as f, expandTable as g, expandTableSlots as h, floorObjects as i, floorOverviewTranslations as j, floorsOf as k, layoutFloorOverview as l, owningSectionForObject as m, pointInPolygonWithHoles as n, objectCenter as o, pointInPolygon as p, polygonLabelPoint as q, rowInventoryCount as r, rowSeatPositions as s, stackFloors as t, tableInventoryCount as u, tableSeatCountsBySide as v, translateObject as w };

package/dist/layout-Dlv5bIf2.d.cts

@@ -0,0 +1,181 @@
+import { A as AccessibilityType, S as SeatOverride, R as RowObject, a as SeatViewMetadata, L as LabelStyle, b as RectTableSide, C as ChartDoc, c as ChartObject, B as BoothObject, T as TableObject, P as Point, F as Floor, d as SectionObject, e as RectTableSeatCounts } from './types-DTSG6_Hq.cjs';
+import { S as SegmentedRowPlacement } from './segmentedRowModel-BNXEUeHp.cjs';
+import { E as ExpandedSeat } from './renderer-DySMcKAR.cjs';
+
+/**
+ * Pure geometry helpers — no Konva, no DOM. Turns the parametric chart
+ * document into concrete seat coordinates and computes bounding boxes.
+ */
+
+/**
+ * Expand a parametric row into seat positions.
+ *
+ * Straight (curve === 0): seat i sits at local (i·spacing, 0).
+ *
+ * Curved: seats lie on a circular arc. Per-seat angular step is
+ * `curve/(seatCount-1)`; radius is derived so the chord between neighbours
+ * equals seatSpacing → radius = spacing / (2·sin(step/2)). Seat 0 sits at the
+ * bottom of the arc (local origin) with the circle centre directly above it at
+ * (0,-radius); increasing index sweeps toward +x while the ends rise toward -y,
+ * i.e. positive curve is concave toward -y (a row wrapping a stage above it).
+ * Local points are then rotated by `rotation` and translated to `origin`.
+ *
+ * Numbering (labels only, never geometry): `seatNumbering.direction === 'rtl'`
+ * numbers from the far physical end; `step === 2` produces odd/even numbering
+ * (start at 1 → 1,3,5…; start at 2 → 2,4,6…).
+ */
+/** 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
+ * but a skipped slot is flagged, not omitted.
+ */
+interface RowSeatSlot {
+    index: number;
+    x: number;
+    y: number;
+    label: string;
+    displayLabel: string;
+    categoryKey: string;
+    skipped: boolean;
+    accessible: boolean;
+    accessibility: AccessibilityType[];
+    wheelchairSpaceType?: SeatOverride['wheelchairSpaceType'];
+    commercial?: RowObject['commercial'];
+    viewUrl?: string;
+    viewMeta?: SeatViewMetadata;
+    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;
+}
+/**
+ * Seat slots for one physical row.
+ *
+ * `placement` makes the slots read as part of a logical segmented row: labels
+ * continue across components (`A-8`, not a second `A-1`) using the logical row's
+ * numbering scheme and total seat count.
+ */
+declare function expandRowSlots(row: RowObject, placement?: SegmentedRowPlacement): RowSeatSlot[];
+declare function expandRow(row: RowObject): ExpandedSeat[];
+/**
+ * Expand a table into its perimeter seats.
+ *
+ * Round: seats spread evenly on a circle of radius `radius + 16`, the first at
+ * angle `rotation` (degrees, clockwise from +x). Rect: seats line the top and
+ * 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[];
+/** Ray-cast point-in-polygon test — odd crossings ⇒ inside. */
+declare function pointInPolygon(p: Point, poly: Point[]): boolean;
+declare function pointInPolygonWithHoles(p: Point, outer: Point[], holes: Point[][] | undefined): boolean;
+/**
+ * Stable interior label anchor: the centre of the largest circle that fits in
+ * the polygon (holes excluded).
+ *
+ * This used to return the average-of-vertices centroid whenever that happened
+ * to be inside, and only fell back to a coarse 24×24 grid search when it was
+ * not. "Inside" is a much weaker property than "has room": on a traced arena
+ * the outer arc of a wedge carries dozens of sampled vertices and the radial
+ * edges carry two, so the average is dragged onto the arc and the label pill —
+ * far wider than a point — straddled the boundary into the next section.
+ * Measured on the 36-section traced arena corpus, 15 of 36 anchors had under
+ * 75% of the clearance actually available, some as little as 43%.
+ *
+ * `polygonInscribedAnchor` is deterministic and coordinate-free, so callers may
+ * memoize it on geometry alone.
+ */
+declare function polygonLabelPoint(outer: Point[], holes: Point[][] | undefined): Point;
+/**
+ * Visual centre of any object — used for spatial section membership and for
+ * rotating an object about its centre. Rows: centroid of expanded seats (or
+ * origin when empty); tables/booths: centre; GA/section: polygon centroid;
+ * 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
+ * to reason about floors goes through this so single-floor charts stay untouched.
+ */
+declare function floorsOf(doc: ChartDoc): Floor[];
+/** Objects of one floor by id (defaults to the first floor). */
+declare function floorObjects(doc: ChartDoc, floorId?: string): ChartObject[];
+/** Every object across ALL floors — the whole venue (single-floor = `doc.objects`). */
+declare function allObjects(doc: ChartDoc): ChartObject[];
+/** A copy of an object translated by (dx, dy) — every coordinate field shifted. */
+declare function translateObject(o: ChartObject, dx: number, dy: number): ChartObject;
+/**
+ * Multi-floor 3D stack (Batch 5): flatten every floor into ONE doc with floor `i`
+ * lifted by `i * spread` in −y, so the isometric view shows the floors as stacked
+ * decks (ground at the bottom). Returns a single-floor doc (no `floors`). Meant
+ * only for the 3D overview render — 2D still shows one floor via `floorObjects`.
+ */
+declare function stackFloors(doc: ChartDoc, spread?: number): ChartDoc;
+/**
+ * Build the buyer-facing 2D overview of a multi-floor chart.
+ *
+ * Floors commonly reuse the same drawing origin (a balcony is authored over
+ * the stalls it overlooks). Flattening those source coordinates makes a valid
+ * import look corrupt because every level is painted on top of every other
+ * level. This projection packs complete floors into a compact, content-aware
+ * grid. Each floor receives one rigid translation: no seat, row, section,
+ * annotation, gap, or rotation changes, and the canonical document is never
+ * mutated.
+ */
+declare function layoutFloorOverview(doc: ChartDoc): ChartDoc;
+/**
+ * Rigid per-floor translations used by the buyer's complete-venue overview.
+ *
+ * Kept as a pure public helper so 2D and 3D can present the same non-overlapping
+ * level arrangement without either renderer rewriting the authored chart. A
+ * zero translation is returned for a single-floor document.
+ */
+declare function floorOverviewTranslations(doc: ChartDoc): Point[];
+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;
+    /** Resolve per-seat 3D eye heights (default true). Two-dimensional consumers
+     * such as thumbnails can disable this expensive stand-structure pass. */
+    resolveEyeHeights?: boolean;
+}
+/** 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;
+    y: number;
+    width: number;
+    height: number;
+};
+
+export { type ExpandChartOptions as E, type RowSeatSlot as R, type TableSeatSlot as T, allObjects as a, expandChart as b, chartBounds as c, expandRow as d, expandBooth as e, expandRowSlots as f, expandTable as g, expandTableSlots as h, floorObjects as i, floorOverviewTranslations as j, floorsOf as k, layoutFloorOverview as l, owningSectionForObject as m, pointInPolygonWithHoles as n, objectCenter as o, pointInPolygon as p, polygonLabelPoint as q, rowInventoryCount as r, rowSeatPositions as s, stackFloors as t, tableInventoryCount as u, tableSeatCountsBySide as v, translateObject as w };

package/dist/renderedQuality-B3jgdgPO.d.ts

@@ -0,0 +1,113 @@
+import { R as RendererQualityEvidence, a as RenderedFreeTextEvidence } from './renderer-B_g-W_QB.js';
+
+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;
+
+export { RENDERED_QUALITY_REPORT_VERSION as R, type RenderedEvidenceState as a, type RenderedQualityFinding as b, type RenderedQualityFindingCode as c, type RenderedQualityReport as d, type RenderedQualitySample as e, inspectRenderedQualityEvidence as i };