@seatlayer/core 0.23.0 → 0.25.0

package/dist/index.js

@@ -111,6 +111,53 @@ function transformSectionOutlinePath(path, transform, radiusScale = 1, reflected
   };
 }
 
+// src/core/labeling.ts
+var FULL_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+var LOWER_ALPHABET = "abcdefghijklmnopqrstuvwxyz";
+function toBijectiveBase(index, alphabet) {
+  const base = alphabet.length;
+  let n = index + 1;
+  let out = "";
+  while (n > 0) {
+    n -= 1;
+    const rem = n % base;
+    out = alphabet[rem] + out;
+    n = Math.floor(n / base);
+  }
+  return out;
+}
+function toLetters(value, lower = false) {
+  const alphabet = lower ? LOWER_ALPHABET : FULL_ALPHABET;
+  return toBijectiveBase(Math.max(0, Math.floor(value) - 1), alphabet);
+}
+var ROMAN_TABLE = [
+  [1e3, "M"],
+  [900, "CM"],
+  [500, "D"],
+  [400, "CD"],
+  [100, "C"],
+  [90, "XC"],
+  [50, "L"],
+  [40, "XL"],
+  [10, "X"],
+  [9, "IX"],
+  [5, "V"],
+  [4, "IV"],
+  [1, "I"]
+];
+function toRoman(value) {
+  if (!Number.isFinite(value) || value <= 0) return String(value);
+  let remaining = Math.floor(value);
+  let out = "";
+  for (const [n, sym] of ROMAN_TABLE) {
+    while (remaining >= n) {
+      out += sym;
+      remaining -= n;
+    }
+  }
+  return out;
+}
+
 // src/core/layout.ts
 function overrideAccessibility(o) {
   if (!o) return [];
@@ -156,24 +203,62 @@ function overrideMap(row) {
   if (row.overrides) for (const o of row.overrides) m.set(o.index, o);
   return m;
 }
-function expandRowSlots(row) {
-  const start = row.seatLabelStart ?? 1;
+function centerRank(n) {
+  const rank = new Array(n);
+  Array.from({ length: n }, (_, i) => i).sort((a, b) => Math.abs(2 * a - (n - 1)) - Math.abs(2 * b - (n - 1)) || a - b).forEach((idx, k) => rank[idx] = k);
+  return rank;
+}
+function seatLabelPart(row, i) {
+  const rawStart = row.seatLabelStart ?? 1;
   const dir = row.seatNumbering?.direction ?? "ltr";
   const step = row.seatNumbering?.step ?? 1;
+  const scheme = row.seatNumbering?.scheme ?? "decimal";
+  const prefix = row.seatNumbering?.prefix ?? "";
+  const endAt = row.seatNumbering?.endAt;
   const n = row.seatCount;
-  let seatNumber;
-  if (dir === "center") {
-    const rank = new Array(n);
-    Array.from({ length: n }, (_, i) => i).sort((a, b) => Math.abs(2 * a - (n - 1)) - Math.abs(2 * b - (n - 1)) || a - b).forEach((idx, k) => rank[idx] = k);
-    seatNumber = (i) => start + rank[i] * step;
-  } else {
-    seatNumber = (i) => start + (dir === "rtl" ? n - 1 - i : i) * step;
+  if (scheme === "updown") {
+    const half = Math.ceil(n / 2);
+    const core2 = i < half ? rawStart + 2 * i : rawStart - 1 + 2 * (n - i);
+    return `${prefix}${core2}`;
+  }
+  const effStep = scheme === "odd" || scheme === "even" ? 2 : step;
+  const start = endAt != null && Number.isFinite(endAt) ? endAt - (n - 1) * effStep : rawStart;
+  const p = dir === "center" ? centerRank(n)[i] : dir === "rtl" ? n - 1 - i : i;
+  let core;
+  switch (scheme) {
+    case "odd": {
+      const firstOdd = start % 2 === 1 ? start : start + 1;
+      core = String(firstOdd + p * 2);
+      break;
+    }
+    case "even": {
+      const firstEven = start % 2 === 0 ? start : start + 1;
+      core = String(firstEven + p * 2);
+      break;
+    }
+    case "roman":
+      core = toRoman(start + p * step);
+      break;
+    case "letters-upper":
+      core = toLetters(start + p * step, false);
+      break;
+    case "letters-lower":
+      core = toLetters(start + p * step, true);
+      break;
+    case "decimal":
+    default:
+      core = String(start + p * step);
+      break;
   }
+  return `${prefix}${core}`;
+}
+function expandRowSlots(row) {
   const ov = overrideMap(row);
   return rowSeatPositions(row).map((p, i) => {
     const o = ov.get(i);
     const accessibility = overrideAccessibility(o);
-    const inventoryLabel = o?.label ?? `${row.label}-${seatNumber(i)}`;
+    const part = seatLabelPart(row, i);
+    const inventoryLabel = o?.label ?? `${row.label}-${part}`;
     const displayPrefix = row.displayLabel ?? row.label;
     const commercial = { ...row.commercial, ...o?.commercial };
     return {
@@ -181,7 +266,7 @@ function expandRowSlots(row) {
       x: p.x + (o?.dx ?? 0),
       y: p.y + (o?.dy ?? 0),
       label: inventoryLabel,
-      displayLabel: o?.displayLabel ?? `${displayPrefix}-${seatNumber(i)}`,
+      displayLabel: o?.displayLabel ?? `${displayPrefix}-${part}`,
       categoryKey: o?.categoryKey ?? row.categoryKey,
       skipped: !!o?.skip,
       accessible: accessibility.length > 0,
@@ -638,19 +723,6 @@ function applyHidden(doc, hidden) {
   return { ...doc, objects };
 }
 
-// src/engine/SeatmapRenderer.ts
-import { Konva } from "konva/lib/Core";
-import { Stage } from "konva/lib/Stage";
-import { Layer } from "konva/lib/Layer";
-import { Group } from "konva/lib/Group";
-import { Circle } from "konva/lib/shapes/Circle";
-import { Rect } from "konva/lib/shapes/Rect";
-import { Ellipse } from "konva/lib/shapes/Ellipse";
-import { Line } from "konva/lib/shapes/Line";
-import { Text } from "konva/lib/shapes/Text";
-import { Image as KImage } from "konva/lib/shapes/Image";
-import { Shape } from "konva/lib/Shape";
-
 // src/core/chartRenderRules.ts
 var SEAT_LABEL_FONT_SIZE = 7;
 var BOOTH_LABEL_FONT_SIZE = 10;
@@ -664,6 +736,8 @@ var LIGHT_BOOKABLE_LABEL_INK = "#ffffff";
 function isBookableLabelLegibleAtScale(fontSize, effectiveScale) {
   return fontSize * effectiveScale >= MIN_VISIBLE_BOOKABLE_LABEL_PX;
 }
+var ACCESS_GLYPH_VIEWBOX = 24;
+var ACCESS_GLYPH_PATH = "M12 2c1.1 0 2 .9 2 2s-.9 2-2 2-2-.9-2-2 .9-2 2-2zm9 7h-6v13h-2v-6h-2v6H9V9H3V7h18v2z";
 function bookableMarkerLabel(publicLabel) {
   return /-(\d{1,5})$/.exec(publicLabel)?.[1] ?? publicLabel;
 }
@@ -705,6 +779,470 @@ function stateAwareBookableLabelInk(fill, preferred) {
   return darkContrast >= lightContrast ? DARK_BOOKABLE_LABEL_INK : LIGHT_BOOKABLE_LABEL_INK;
 }
 
+// src/core/renderedQuality.ts
+var RENDERED_QUALITY_REPORT_VERSION = 3;
+var MIN_TEXT_CONTRAST = 4.5;
+var MIN_GRAPHICAL_CONTRAST = 3;
+var MIN_POINTER_TARGET_PX = 24;
+var MAX_SAMPLES_PER_FINDING = 20;
+function visibleWithBox(items) {
+  return items.filter((item) => item.visible && Boolean(item.screenBox));
+}
+function intersects(left, right) {
+  return left.x < right.x + right.width && left.x + left.width > right.x && left.y < right.y + right.height && left.y + left.height > right.y;
+}
+function minimum(values) {
+  return values.length ? Math.round(Math.min(...values) * 100) / 100 : null;
+}
+function finding(code, message, samples) {
+  if (!samples.length) return null;
+  return {
+    code,
+    message,
+    count: samples.length,
+    samples: samples.slice(0, MAX_SAMPLES_PER_FINDING)
+  };
+}
+function labelSample(label, measured, minimumValue) {
+  return {
+    primaryId: label.seatId,
+    primaryLabel: label.label,
+    ...measured == null ? {} : { measured: Math.round(measured * 100) / 100 },
+    ...minimumValue == null ? {} : { minimum: minimumValue }
+  };
+}
+function hierarchySample(label, measured, minimumValue) {
+  return {
+    primaryId: label.id,
+    primaryLabel: label.label,
+    ...measured == null ? {} : { measured: Math.round(measured * 100) / 100 },
+    ...minimumValue == null ? {} : { minimum: minimumValue }
+  };
+}
+function freeTextSample(label, measured, minimumValue) {
+  return {
+    primaryId: label.objectId,
+    primaryLabel: label.text,
+    ...measured == null ? {} : { measured: Math.round(measured * 100) / 100 },
+    ...minimumValue == null ? {} : { minimum: minimumValue }
+  };
+}
+function collisionSample(primaryId, primaryLabel, secondaryId, secondaryLabel) {
+  return { primaryId, primaryLabel, secondaryId, secondaryLabel };
+}
+function inspectRenderedQualityEvidence(evidence, state = "overview", targetCategoryKey = null) {
+  const bookable = visibleWithBox(evidence.labels);
+  const hierarchy = visibleWithBox(evidence.hierarchyLabels);
+  const freeText = visibleWithBox(evidence.freeTextLabels);
+  const visibleGA = evidence.gaAreas.filter((area) => area.visible);
+  const bookableContrast = bookable.map((label) => renderedTextContrast(label.ink, label.fill) ?? 0);
+  const hierarchyContrast = hierarchy.map((label) => renderedTextContrast(label.ink, label.fill) ?? 0);
+  const freeTextContrast = freeText.map((label) => renderedTextContrast(label.ink, label.background) ?? 0);
+  const gaContrast = visibleGA.map((area) => renderedTextContrast(area.effectiveBackground, evidence.canvasBackground) ?? 0);
+  const targetLabels = targetCategoryKey ? evidence.labels.filter((label) => label.categoryKey === targetCategoryKey) : evidence.labels;
+  const targetGAAreas = targetCategoryKey ? evidence.gaAreas.filter((area) => area.categoryKey === targetCategoryKey) : evidence.gaAreas;
+  const selected = targetLabels.filter((label) => label.selected);
+  const held = targetLabels.filter((label) => label.status === "held");
+  const booked = targetLabels.filter((label) => label.status === "booked");
+  const activePointerTargets = targetLabels.filter((label) => label.pointerTarget.active);
+  const activeCategoryKeys = /* @__PURE__ */ new Set([
+    ...evidence.labels.filter((label) => label.visible && (label.opacity > 0.25 || label.selected || label.status !== "free")).map((label) => label.categoryKey),
+    ...evidence.gaAreas.filter((area) => area.visible && area.opacity > 0.1).map((area) => area.categoryKey)
+  ]);
+  const selectedRingContrast = selected.length ? minimum(selected.flatMap((label) => [
+    renderedTextContrast(evidence.selectionRingColor, evidence.canvasBackground) ?? 0,
+    renderedTextContrast(evidence.selectionRingColor, label.fill) ?? 0
+  ])) : null;
+  const findings = [];
+  const overviewCountSamples = (count, label) => Array.from({ length: count }, (_, index) => ({
+    primaryId: `overview:${index + 1}`,
+    primaryLabel: label
+  }));
+  if (state === "overview" && evidence.rung === "sections") {
+    findings.push(finding(
+      "overview-section-category-paint",
+      "Section overview shells must use the neutral hierarchy palette, not category paint",
+      overviewCountSamples(evidence.overviewStyle.categoryPaintedSectionShells, "category-painted section shell")
+    ));
+    findings.push(finding(
+      "overview-category-detail-visible",
+      "Category-tinted section detail must wait until section focus or seat zoom",
+      overviewCountSamples(evidence.overviewStyle.visibleCategoryDetailOutlines, "category detail outline")
+    ));
+    findings.push(finding(
+      "overview-row-hints-visible",
+      "Row and seat patterns must not clutter the section overview",
+      overviewCountSamples(evidence.overviewStyle.visibleSectionRowHints, "section row hint")
+    ));
+    findings.push(finding(
+      "overview-availability-clutter",
+      "Live availability counts belong in focused detail, not on section overview shells",
+      overviewCountSamples(evidence.overviewStyle.visibleSectionAvailabilityLabels, "section availability label")
+    ));
+    findings.push(finding(
+      "overview-ga-detail-visible",
+      "Section-contained standing paint belongs in focused detail, not on section overview shells",
+      overviewCountSamples(evidence.overviewStyle.visibleSectionGADetails, "section-contained GA detail")
+    ));
+  }
+  findings.push(finding(
+    "bookable-label-undersized",
+    "Visible bookable labels must meet the rendered small-text size floor",
+    bookable.filter((label) => label.renderedFontPx < evidence.minimumVisibleLabelPx).map((label) => labelSample(label, label.renderedFontPx, evidence.minimumVisibleLabelPx))
+  ));
+  if (state === "interaction") {
+    const labelledInventory = targetLabels.length > 0;
+    const gaInventory = targetGAAreas.length > 0;
+    const detailInventory = labelledInventory || gaInventory;
+    const visibleTargetGA = targetGAAreas.filter((area) => area.visible);
+    const sections = /* @__PURE__ */ new Set([
+      ...targetLabels.flatMap((label) => label.sectionId ? [label.sectionId] : []),
+      ...targetGAAreas.flatMap((area) => area.sectionId ? [area.sectionId] : [])
+    ]);
+    const categories = /* @__PURE__ */ new Set([
+      ...evidence.labels.map((label) => label.categoryKey),
+      ...evidence.gaAreas.map((area) => area.categoryKey)
+    ]);
+    const inViewport = (label) => label.screenCenter.x >= 0 && label.screenCenter.x <= evidence.viewport.width && label.screenCenter.y >= 0 && label.screenCenter.y <= evidence.viewport.height;
+    findings.push(finding(
+      "detail-rung-missing",
+      "Interaction evidence with bookable inventory must render the seat-detail rung",
+      detailInventory && evidence.rung !== "seats" ? [{ primaryId: "renderer", primaryLabel: evidence.rung }] : []
+    ));
+    findings.push(finding(
+      "detail-inventory-not-visible",
+      "Interaction evidence must frame at least one real bookable unit",
+      detailInventory && !targetLabels.some(inViewport) && !visibleTargetGA.length ? [{ primaryId: "renderer", primaryLabel: "no target inventory in viewport" }] : []
+    ));
+    findings.push(finding(
+      "pointer-target-inactive",
+      "Interaction evidence must expose a live production pointer target",
+      labelledInventory && !activePointerTargets.some(inViewport) || !labelledInventory && gaInventory && !visibleTargetGA.some((area) => area.interactive) ? [{ primaryId: "renderer", primaryLabel: "no active pointer target in viewport" }] : []
+    ));
+    findings.push(finding(
+      "pointer-target-undersized",
+      "Every active production pointer target must reach at least 24 CSS pixels",
+      activePointerTargets.filter((label) => inViewport(label) && label.pointerTarget.effectiveMinimumPx < MIN_POINTER_TARGET_PX).map((label) => labelSample(label, label.pointerTarget.effectiveMinimumPx, MIN_POINTER_TARGET_PX))
+    ));
+    findings.push(finding(
+      "selected-state-missing",
+      "Interaction evidence must paint a selected unit and its renderer-owned ring",
+      labelledInventory && (!selected.length || !selected.some((label) => evidence.selectionRingSeatIds.includes(label.seatId))) ? [{ primaryId: "renderer", primaryLabel: "selected state" }] : []
+    ));
+    findings.push(finding(
+      "selected-state-contrast-low",
+      "The selected-state ring must maintain 3:1 graphical contrast with the canvas",
+      selected.length && (selectedRingContrast ?? 0) < MIN_GRAPHICAL_CONTRAST ? [{
+        primaryId: selected[0].seatId,
+        primaryLabel: selected[0].label,
+        measured: Math.round((selectedRingContrast ?? 0) * 100) / 100,
+        minimum: MIN_GRAPHICAL_CONTRAST
+      }] : []
+    ));
+    findings.push(finding(
+      "held-state-missing",
+      "Interaction evidence must paint a held state when the floor has at least two status-managed units",
+      targetLabels.length >= 2 && !held.length ? [{ primaryId: "renderer", primaryLabel: "held state" }] : []
+    ));
+    findings.push(finding(
+      "booked-state-missing",
+      "Interaction evidence must paint a taken state when the floor has at least three status-managed units",
+      targetLabels.length >= 3 && !booked.length ? [{ primaryId: "renderer", primaryLabel: "booked state" }] : []
+    ));
+    const heldSignatures = new Set(held.map((label) => `${label.fill.toLowerCase()}:${label.opacity}`));
+    const bookedSignatures = new Set(booked.map((label) => `${label.fill.toLowerCase()}:${label.opacity}`));
+    findings.push(finding(
+      "status-state-indistinct",
+      "Held and taken evidence must resolve to distinct renderer paint",
+      held.length && booked.length && [...heldSignatures].some((signature) => bookedSignatures.has(signature)) ? [{ primaryId: held[0].seatId, primaryLabel: held[0].label, secondaryId: booked[0].seatId, secondaryLabel: booked[0].label }] : []
+    ));
+    findings.push(finding(
+      "section-focus-missing",
+      "Interaction evidence must exercise section focus and its backdrop when section membership exists",
+      sections.size && (!evidence.focusedSectionId || !evidence.focusBackdropVisible) ? [{ primaryId: "renderer", primaryLabel: "section focus" }] : []
+    ));
+    findings.push(finding(
+      "category-filter-missing",
+      "Interaction evidence must exercise a category filter when multiple categories exist",
+      categories.size >= 2 && (!evidence.categoryFilterKeys || !evidence.categoryFilterKeys.length) ? [{ primaryId: "renderer", primaryLabel: "category filter" }] : []
+    ));
+    const excludedFree = evidence.labels.filter((label) => label.status === "free" && !label.selected && evidence.categoryFilterKeys != null && !evidence.categoryFilterKeys.includes(label.categoryKey));
+    const excludedGA = evidence.gaAreas.filter((area) => evidence.categoryFilterKeys != null && !evidence.categoryFilterKeys.includes(area.categoryKey));
+    findings.push(finding(
+      "category-filter-ineffective",
+      "The active category filter must visibly dim excluded free inventory",
+      (excludedFree.length || excludedGA.length) && !excludedFree.some((label) => label.opacity <= 0.25) && !excludedGA.some((area) => area.opacity <= 0.1) ? [
+        ...excludedFree.map((label) => labelSample(label, label.opacity)),
+        ...excludedGA.map((area) => ({ primaryId: area.areaId, primaryLabel: area.label, measured: area.opacity }))
+      ] : []
+    ));
+    findings.push(finding(
+      "target-category-not-visible",
+      "A category-specific interaction scene must visibly paint its exact target category",
+      targetCategoryKey && !activeCategoryKeys.has(targetCategoryKey) ? [{ primaryId: targetCategoryKey, primaryLabel: targetCategoryKey }] : []
+    ));
+    findings.push(finding(
+      "target-category-filter-mismatch",
+      "A category-specific interaction scene must bind its filter to only the exact target category",
+      targetCategoryKey && (evidence.categoryFilterKeys?.length !== 1 || evidence.categoryFilterKeys[0] !== targetCategoryKey) ? [{ primaryId: targetCategoryKey, primaryLabel: targetCategoryKey }] : []
+    ));
+  }
+  findings.push(finding(
+    "bookable-label-contrast-low",
+    "Visible bookable labels must meet 4.5:1 contrast against their actual paint",
+    bookable.flatMap((label) => {
+      const ratio = renderedTextContrast(label.ink, label.fill) ?? 0;
+      return ratio < MIN_TEXT_CONTRAST ? [labelSample(label, ratio, MIN_TEXT_CONTRAST)] : [];
+    })
+  ));
+  const bookableCollisions = [];
+  for (let index = 0; index < bookable.length; index += 1) {
+    for (let other = 0; other < index; other += 1) {
+      if (intersects(bookable[index].screenBox, bookable[other].screenBox)) {
+        bookableCollisions.push(collisionSample(
+          bookable[other].seatId,
+          bookable[other].label,
+          bookable[index].seatId,
+          bookable[index].label
+        ));
+      }
+    }
+  }
+  findings.push(finding(
+    "bookable-label-collision",
+    "Visible bookable labels must not overlap",
+    bookableCollisions
+  ));
+  findings.push(finding(
+    "hierarchy-label-undersized",
+    "Visible section and zone labels must meet the rendered small-text size floor",
+    hierarchy.filter((label) => label.renderedFontPx < MIN_VISIBLE_BOOKABLE_LABEL_PX).map((label) => hierarchySample(label, label.renderedFontPx, MIN_VISIBLE_BOOKABLE_LABEL_PX))
+  ));
+  findings.push(finding(
+    "hierarchy-label-contrast-low",
+    "Visible section and zone labels must meet 4.5:1 contrast against their backing paint",
+    hierarchy.flatMap((label) => {
+      const ratio = renderedTextContrast(label.ink, label.fill) ?? 0;
+      return ratio < MIN_TEXT_CONTRAST ? [hierarchySample(label, ratio, MIN_TEXT_CONTRAST)] : [];
+    })
+  ));
+  findings.push(finding(
+    "hierarchy-label-outside-section",
+    "Visible section labels must remain inside the filled section surface and outside holes",
+    hierarchy.filter((label) => label.kind === "section" && label.fitsContainer === false).map((label) => hierarchySample(label))
+  ));
+  const hierarchyCollisions = [];
+  for (let index = 0; index < hierarchy.length; index += 1) {
+    for (let other = 0; other < index; other += 1) {
+      if (intersects(hierarchy[index].screenBox, hierarchy[other].screenBox)) {
+        hierarchyCollisions.push(collisionSample(
+          hierarchy[other].id,
+          hierarchy[other].label,
+          hierarchy[index].id,
+          hierarchy[index].label
+        ));
+      }
+    }
+  }
+  findings.push(finding(
+    "hierarchy-label-collision",
+    "Visible hierarchy labels must not overlap each other",
+    hierarchyCollisions
+  ));
+  const hierarchyBookableCollisions = [];
+  for (const upper of hierarchy) {
+    for (const unit of bookable) {
+      if (intersects(upper.screenBox, unit.screenBox)) {
+        hierarchyBookableCollisions.push(collisionSample(upper.id, upper.label, unit.seatId, unit.label));
+      }
+    }
+  }
+  findings.push(finding(
+    "hierarchy-bookable-collision",
+    "Visible hierarchy labels must not overlap bookable labels",
+    hierarchyBookableCollisions
+  ));
+  findings.push(finding(
+    "free-text-undersized",
+    "Visible chart text must meet the rendered small-text size floor",
+    freeText.filter((label) => label.renderedFontPx < evidence.minimumVisibleLabelPx).map((label) => freeTextSample(label, label.renderedFontPx, evidence.minimumVisibleLabelPx))
+  ));
+  findings.push(finding(
+    "free-text-contrast-low",
+    "Visible chart text must meet 4.5:1 contrast against its measured background",
+    freeText.flatMap((label) => {
+      const ratio = renderedTextContrast(label.ink, label.background) ?? 0;
+      return ratio < MIN_TEXT_CONTRAST ? [freeTextSample(label, ratio, MIN_TEXT_CONTRAST)] : [];
+    })
+  ));
+  const freeTextCollisions = [];
+  for (let index = 0; index < freeText.length; index += 1) {
+    for (let other = 0; other < index; other += 1) {
+      if (intersects(freeText[index].screenBox, freeText[other].screenBox)) {
+        freeTextCollisions.push(collisionSample(
+          freeText[other].objectId,
+          freeText[other].text,
+          freeText[index].objectId,
+          freeText[index].text
+        ));
+      }
+    }
+  }
+  findings.push(finding(
+    "free-text-collision",
+    "Visible chart text labels must not overlap each other",
+    freeTextCollisions
+  ));
+  const freeTextBookableCollisions = [];
+  for (const text of freeText) {
+    for (const unit of bookable) {
+      if (intersects(text.screenBox, unit.screenBox)) {
+        freeTextBookableCollisions.push(collisionSample(text.objectId, text.text, unit.seatId, unit.label));
+      }
+    }
+  }
+  findings.push(finding(
+    "free-text-bookable-collision",
+    "Visible chart text must not overlap bookable labels",
+    freeTextBookableCollisions
+  ));
+  const freeTextHierarchyCollisions = [];
+  for (const text of freeText) {
+    for (const upper of hierarchy) {
+      if (intersects(text.screenBox, upper.screenBox)) {
+        freeTextHierarchyCollisions.push(collisionSample(text.objectId, text.text, upper.id, upper.label));
+      }
+    }
+  }
+  findings.push(finding(
+    "free-text-hierarchy-collision",
+    "Visible chart text must not overlap hierarchy labels",
+    freeTextHierarchyCollisions
+  ));
+  findings.push(finding(
+    "ga-contrast-low",
+    "Visible GA surfaces must maintain 3:1 graphical contrast with the canvas",
+    visibleGA.flatMap((area) => {
+      const ratio = renderedTextContrast(area.effectiveBackground, evidence.canvasBackground) ?? 0;
+      return ratio < MIN_GRAPHICAL_CONTRAST ? [{
+        primaryId: area.areaId,
+        primaryLabel: area.label,
+        measured: Math.round(ratio * 100) / 100,
+        minimum: MIN_GRAPHICAL_CONTRAST
+      }] : [];
+    })
+  ));
+  const materialFindings = findings.filter((item) => Boolean(item));
+  return {
+    version: RENDERED_QUALITY_REPORT_VERSION,
+    passed: materialFindings.length === 0,
+    state,
+    targetCategoryKey,
+    resolvedRules: [
+      "rendered-overview-label-size",
+      "rendered-overview-label-contrast",
+      "rendered-overview-label-collision",
+      "rendered-overview-hierarchy-containment",
+      "rendered-overview-section-first-style",
+      "rendered-overview-ga-contrast",
+      ...state === "interaction" ? [
+        "rendered-detail-inventory",
+        "rendered-pointer-target",
+        "rendered-selected-held-taken-states",
+        "rendered-section-focus",
+        "rendered-category-filter"
+      ] : []
+    ],
+    viewport: evidence.viewport,
+    canvasBackground: evidence.canvasBackground,
+    effectiveScale: evidence.effectiveScale,
+    rung: evidence.rung,
+    inventory: {
+      totalBookableUnits: evidence.totalBookableUnits,
+      totalLabelledBookableUnits: evidence.totalLabelledBookableUnits,
+      visibleBookableLabels: bookable.length,
+      hiddenBookableLabels: evidence.hiddenLabels,
+      visibleHierarchyLabels: hierarchy.length,
+      visibleFreeTextLabels: freeText.length,
+      visibleGAAreas: visibleGA.length
+    },
+    overviewStyle: evidence.overviewStyle,
+    composition: {
+      hierarchy: evidence.hierarchyLabels.filter((label) => label.role === "name").map((label) => ({
+        id: label.id,
+        kind: label.kind,
+        label: label.label,
+        visible: label.visible
+      })).sort((left, right) => left.kind.localeCompare(right.kind) || left.id.localeCompare(right.id)),
+      labelledObjects: evidence.freeTextLabels.map((label) => ({
+        objectId: label.objectId,
+        kind: label.kind,
+        text: label.text,
+        visible: label.visible
+      })).sort((left, right) => left.objectId.localeCompare(right.objectId) || left.kind.localeCompare(right.kind)),
+      gaAreas: evidence.gaAreas.map((area) => ({
+        areaId: area.areaId,
+        label: area.label,
+        categoryKey: area.categoryKey,
+        ...area.sectionId ? { sectionId: area.sectionId } : {},
+        visible: area.visible
+      })).sort((left, right) => left.areaId.localeCompare(right.areaId)),
+      bookableSectionIds: [...new Set(evidence.labels.flatMap((label) => label.sectionId ? [label.sectionId] : []))].sort(),
+      categoryKeys: [.../* @__PURE__ */ new Set([
+        ...evidence.labels.map((label) => label.categoryKey),
+        ...evidence.gaAreas.map((area) => area.categoryKey)
+      ])].sort(),
+      activeCategoryKeys: [...activeCategoryKeys].sort()
+    },
+    metrics: {
+      minimumRenderedBookableLabelPx: minimum(bookable.map((label) => label.renderedFontPx)),
+      minimumBookableLabelContrast: minimum(bookableContrast),
+      minimumRenderedHierarchyLabelPx: minimum(hierarchy.map((label) => label.renderedFontPx)),
+      minimumHierarchyLabelContrast: minimum(hierarchyContrast),
+      minimumRenderedFreeTextPx: minimum(freeText.map((label) => label.renderedFontPx)),
+      minimumFreeTextContrast: minimum(freeTextContrast),
+      minimumGAContrast: minimum(gaContrast),
+      minimumEffectivePointerTargetPx: minimum(activePointerTargets.map((label) => label.pointerTarget.effectiveMinimumPx)),
+      selectedRingContrast: selectedRingContrast == null ? null : Math.round(selectedRingContrast * 100) / 100
+    },
+    interaction: {
+      applicable: {
+        detail: targetLabels.length > 0 || targetGAAreas.length > 0,
+        pointer: targetLabels.length > 0 || targetGAAreas.length > 0,
+        held: targetLabels.length >= 2,
+        booked: targetLabels.length >= 3,
+        sectionFocus: targetLabels.some((label) => Boolean(label.sectionId)) || targetGAAreas.some((area) => Boolean(area.sectionId)),
+        categoryFilter: (/* @__PURE__ */ new Set([
+          ...evidence.labels.map((label) => label.categoryKey),
+          ...evidence.gaAreas.map((area) => area.categoryKey)
+        ])).size >= 2
+      },
+      selectedUnits: selected.length,
+      heldUnits: held.length,
+      bookedUnits: booked.length,
+      activePointerTargets: activePointerTargets.length,
+      focusedSectionId: evidence.focusedSectionId,
+      focusBackdropVisible: evidence.focusBackdropVisible,
+      categoryFilterKeys: evidence.categoryFilterKeys
+    },
+    findings: materialFindings
+  };
+}
+
+// src/engine/SeatmapRenderer.ts
+import { Konva } from "konva/lib/Core";
+import { Stage } from "konva/lib/Stage";
+import { Layer } from "konva/lib/Layer";
+import { Group } from "konva/lib/Group";
+import { Circle } from "konva/lib/shapes/Circle";
+import { Rect } from "konva/lib/shapes/Rect";
+import { Ellipse } from "konva/lib/shapes/Ellipse";
+import { Line } from "konva/lib/shapes/Line";
+import { Text } from "konva/lib/shapes/Text";
+import { Path } from "konva/lib/shapes/Path";
+import { Image as KImage } from "konva/lib/shapes/Image";
+import { Shape } from "konva/lib/Shape";
+
 // src/lib/money.ts
 var DEFAULT_CURRENCY = "USD";
 var displayLocale;
@@ -743,29 +1281,17 @@ var en = {
   "common.done": "Done",
   "common.copied": "\u2713 Copied",
   // buyer picker
-  "picker.holdSeats": "Hold seats & checkout",
-  "picker.completeBooking": "Complete booking",
-  "picker.seatsHeld": "Seats held \u2014 {time}",
   "picker.holdExpired": "Your hold expired \u2014 the seats were released. Pick again.",
-  "picker.seatTaken": "Seat {label} was just taken by another buyer.",
   "picker.poweredBy": "Powered by SeatLayer",
   "picker.testMode": "TEST MODE",
-  "picker.colorblind": "Colorblind-friendly colors",
   "picker.orphanHint": "This leaves a single seat stranded \u2014 consider shifting one seat over.",
-  "picker.seats.one": "{count} seat",
-  "picker.seats.other": "{count} seats",
   // renderer (drawn on the Konva map — shared by the embed SDK)
   "map.aria": "Seating map. Use arrow keys to move between seats, Enter to select.",
   "map.seatsLeft": "{count} LEFT",
   "map.fromPrice": "FROM {price}",
   "map.statusHeld": "On hold",
   "map.statusTaken": "Taken",
-  // buyer picker page (src/pages/PickerPage.tsx)
-  "picker.language": "Language",
-  "picker.zoomToFit": "Zoom to fit",
-  "picker.seatCountLabel": "seats",
-  "picker.capacity": "capacity",
-  "picker.viewMode": "View mode",
+  // buyer picker widget (src/picker/widget/SeatPicker.ts)
   "picker.floor": "Floor",
   "picker.zoomLevel": "Zoom level",
   "picker.rungTip.zones": "Venue overview \u2014 groups of sections such as North Stand or VIP",
@@ -779,32 +1305,13 @@ var en = {
   "picker.seatsLeftInSection.one": "{count} seat left",
   "picker.seatsLeftInSection.other": "{count} seats left",
   "picker.overview": "Overview",
+  "picker.entrance": "Entrance",
   "picker.tapSeatHint": "Tap any seat to check its view",
-  "picker.chartSize": "Chart size",
-  "picker.custom": "Custom",
-  "picker.categories": "Categories",
-  "picker.accessibility": "Accessibility",
-  "picker.showAnyAccessible": "Show any accessible seat",
-  "picker.any": "Any",
-  "picker.yourSeats": "Your seats",
-  "picker.emptySeats": "Tap seats on the map",
-  "picker.emptySeatsWithGa": "Tap seats on the map \xB7 tap a standing area for GA tickets",
-  "picker.oneFewer": "One fewer",
-  "picker.oneMore": "One more",
-  "picker.remove": "Remove {label}",
   "picker.ticketTierFor": "Ticket tier for {label}",
-  "picker.total": "Total: {amount}",
   "picker.viewFromSeat": "View from seat {label}",
   "picker.real360": "REAL 360\xB0",
   "picker.preview": "PREVIEW",
-  "picker.open360": "Open 360\xB0 view",
   "picker.sightline": "\u2248 {m} m to stage \xB7 clear sightline",
-  "picker.bookedDemo": "Booked! (demo)",
-  "picker.bookButton.one": "Book {count} ticket \u2014 {amount}",
-  "picker.bookButton.other": "Book {count} tickets \u2014 {amount}",
-  "picker.simulateCrowd": "Simulate crowd: {state}",
-  "picker.on": "ON",
-  "picker.off": "OFF",
   "picker.panorama360": "360\xB0 venue photo",
   "picker.illustrationCaption": "illustration \xB7 \u2248 {m} m from stage",
   "picker.restrictedView": "Restricted view",
@@ -863,6 +1370,7 @@ var CACHE_THRESHOLD = 0.55 * SEAT_LEGIBLE_SCALE;
 var LABEL_SCALE = MIN_VISIBLE_BOOKABLE_LABEL_PX / SEAT_LABEL_FONT_SIZE;
 var MIN_FITTED_SEAT_LABEL_FONT_SIZE = 4;
 var SEAT_TAP_SLOP_PX = 14;
+var SEAT_GLYPH_MIN_PX = 6.5;
 var SECTION_PROMINENT_SCALE = 0.45 * SEAT_LEGIBLE_SCALE;
 var BLOCK_MELT_TOP = 0.9 * SEAT_LEGIBLE_SCALE;
 var SEAT_FOCUS_SCALE = Math.max(SEAT_LEGIBLE_SCALE * 1.1, BLOCK_MELT_TOP);
@@ -1152,6 +1660,15 @@ var _SeatmapRenderer = class _SeatmapRenderer {
     this.boothLabelById = /* @__PURE__ */ new Map();
     /** Viewport seat labels are rebuilt after each settled camera change. */
     this.seatLabelById = /* @__PURE__ */ new Map();
+    /** Coloured accommodation ring per accessible seat (few per chart). */
+    this.accessRingById = /* @__PURE__ */ new Map();
+    /** 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. */
+    this.accessGlyphById = /* @__PURE__ */ new Map();
+    /** Whether the accessibility glyph is legible at the current camera scale. */
+    this.accessGlyphVisible = false;
     /** Authored free-text nodes obey the same rendered-size visibility floor. */
     this.freeTextById = /* @__PURE__ */ new Map();
     /** Stage/rink landmarks retain a readable screen-space caption at overview. */
@@ -1464,6 +1981,8 @@ var _SeatmapRenderer = class _SeatmapRenderer {
     this.boothDims.clear();
     this.boothLabelById.clear();
     this.seatLabelById.clear();
+    this.accessRingById.clear();
+    this.accessGlyphById.clear();
     this.freeTextById.clear();
     this.primaryFocalLabels.clear();
     this.gaById.clear();
@@ -2372,18 +2891,21 @@ var _SeatmapRenderer = class _SeatmapRenderer {
       this.paintSeat(c, seat.id);
       target.add(c);
       if (seat.accessible) {
-        target.add(
-          new Circle({
-            x: seat.x,
-            y: seat.y,
-            radius: this.seatR + 1,
-            stroke: accessibilityRingColor(seat.accessibility),
-            strokeWidth: 2,
-            listening: false,
-            perfectDrawEnabled: false,
-            shadowForStrokeEnabled: false
-          })
-        );
+        const ring = new Circle({
+          x: seat.x,
+          y: seat.y,
+          radius: this.seatR + 1.5,
+          stroke: accessibilityRingColor(seat.accessibility),
+          strokeWidth: 2.5,
+          listening: false,
+          perfectDrawEnabled: false,
+          shadowForStrokeEnabled: false
+        });
+        this.accessRingById.set(seat.id, ring);
+        target.add(ring);
+        const glyph = this.buildAccessGlyph(seat, typeof c.fill() === "string" ? c.fill() : "");
+        this.accessGlyphById.set(seat.id, glyph);
+        target.add(glyph);
       }
     }
   }
@@ -2427,6 +2949,53 @@ var _SeatmapRenderer = class _SeatmapRenderer {
     target.add(t2);
     this.paintSeat(rect, seat.id);
   }
+  /**
+   * Build the centred accessibility glyph for a seat. Sized relative to the seat
+   * radius (so it always fills the marker at any zoom) and given a contrast-aware
+   * fill against the seat's paint — recomputed per state in {@link paintSeat}.
+   */
+  buildAccessGlyph(seat, seatFill) {
+    const k = this.seatR * 1.5 / ACCESS_GLYPH_VIEWBOX;
+    return new Path({
+      x: seat.x,
+      y: seat.y,
+      data: ACCESS_GLYPH_PATH,
+      offsetX: ACCESS_GLYPH_VIEWBOX / 2,
+      offsetY: ACCESS_GLYPH_VIEWBOX / 2,
+      scaleX: k,
+      scaleY: k,
+      fill: stateAwareBookableLabelInk(seatFill, "#ffffff"),
+      listening: false,
+      visible: this.accessGlyphVisible,
+      perfectDrawEnabled: false,
+      shadowForStrokeEnabled: false
+    });
+  }
+  /**
+   * 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.
+   */
+  updateAccessGlyphs(scale) {
+    if (!this.accessGlyphById.size) return;
+    this.accessGlyphVisible = this.seatR * scale >= SEAT_GLYPH_MIN_PX;
+    for (const [id, glyph] of this.accessGlyphById) {
+      glyph.visible(this.accessGlyphVisible && this.accessGlyphEligible(id));
+    }
+  }
+  /**
+   * 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
+   * overlay status cue (diagonal mark / lock) carries the state instead — mirrors
+   * the `unavailable` test in {@link updateLabels} so the two never collide.
+   */
+  accessGlyphEligible(id) {
+    const status = this.statusById.get(id) ?? "free";
+    if (status === "booked") return false;
+    if (status === "held" && !this.ownedHold.has(id) && !this.opts.manageMode) return false;
+    return true;
+  }
   /** The category's display color — Okabe-Ito hue when colorblind-safe is on. */
   seatBaseColor(categoryKey) {
     if (!this.colorblind) return this.catColor.get(categoryKey) ?? "#6e7bff";
@@ -2540,6 +3109,14 @@ var _SeatmapRenderer = class _SeatmapRenderer {
         isBookableLabelLegibleAtScale(bookableLabel.fontSize(), this.effScale()) && c.opacity() >= 0.5
       );
     }
+    const accessGlyph = this.accessGlyphById.get(id);
+    if (accessGlyph) {
+      const fill = c.fill();
+      accessGlyph.fill(stateAwareBookableLabelInk(typeof fill === "string" ? fill : "", "#ffffff"));
+      accessGlyph.opacity(c.opacity());
+      accessGlyph.visible(this.accessGlyphVisible && this.accessGlyphEligible(id));
+    }
+    this.accessRingById.get(id)?.opacity(c.opacity());
   }
   /** True when a seat sits in a section/zone currently marked `closed`. */
   seatInClosedSection(id) {
@@ -4265,6 +4842,7 @@ var _SeatmapRenderer = class _SeatmapRenderer {
     if (this.hasSections) this.applySectionLod(scale);
     else if (this.primaryFocalLabels.size) this.bgLayer.batchDraw();
     this.paintGAStateForView();
+    this.updateAccessGlyphs(scale);
     const shouldCache = scale < CACHE_THRESHOLD;
     if (shouldCache && !this.cached) {
       this.cacheSeatLayer();
@@ -4347,6 +4925,7 @@ var _SeatmapRenderer = class _SeatmapRenderer {
     for (const seat of this.seats) {
       if (seat.kind === "booth") continue;
       if (seat.x < x0 || seat.x > x1 || seat.y < y0 || seat.y > y1) continue;
+      if (seat.accessible && this.accessGlyphVisible) continue;
       const shape = this.circleById.get(seat.id);
       if ((shape?.opacity() ?? 1) < 0.5) continue;
       const status = this.statusById.get(seat.id) ?? "free";
@@ -4696,13 +5275,17 @@ var PickerController = class {
       this.allIds.push(s.id);
       const source = chartObjects.get(s.rowId);
       const sourceLabel = source && "label" in source && typeof source.label === "string" ? source.label : void 0;
-      const rowLabel = s.kind === "booth" ? void 0 : sourceLabel;
-      const labelParts = s.label.split("-");
-      const seatNumber = rowLabel && s.label.startsWith(`${rowLabel}-`) ? s.label.slice(rowLabel.length + 1) : s.kind === "booth" ? s.label : labelParts[labelParts.length - 1] ?? s.label;
+      const sourceDisplayLabel = source && "displayLabel" in source && typeof source.displayLabel === "string" && source.displayLabel ? source.displayLabel : sourceLabel;
+      const rowLabel = s.kind === "booth" ? void 0 : sourceDisplayLabel;
+      const rowType = source && "displayType" in source && typeof source.displayType === "string" && source.displayType.trim() ? source.displayType.trim() : void 0;
+      const visibleSeatLabel = s.displayLabel ?? s.label;
+      const labelParts = visibleSeatLabel.split("-");
+      const seatNumber = sourceDisplayLabel && visibleSeatLabel.startsWith(`${sourceDisplayLabel}-`) ? visibleSeatLabel.slice(sourceDisplayLabel.length + 1) : s.kind === "booth" ? visibleSeatLabel : labelParts[labelParts.length - 1] ?? visibleSeatLabel;
       this.seatContext.set(s.id, {
         sectionLabel: sectionLabels.get(membership.objectToSection.get(s.rowId) ?? ""),
         rowLabel,
-        seatNumber
+        seatNumber,
+        rowType
       });
     }
     const currency = res.event.currency ?? this.opts.currency;
@@ -5337,6 +5920,7 @@ var PickerController = class {
       id,
       label: sec.label,
       zoneLabel: zone?.label ?? "",
+      ...sec.entrance && sec.entrance.trim() ? { entrance: sec.entrance.trim() } : {},
       color,
       seatsLeft,
       priceMin: prices.length ? prices[0] : 0,
@@ -5368,14 +5952,16 @@ var PickerController = class {
   // ---- internals ------------------------------------------------------------
   toSeat(s) {
     const commercial = s.commercial ? { commercial: s.commercial } : void 0;
+    const display = s.displayLabel ? { displayLabel: s.displayLabel } : void 0;
     const tiers = this.tiersFor(s.categoryKey);
     if (!tiers) {
-      return { id: s.id, label: s.label, categoryKey: s.categoryKey, price: this.priceFor(s.categoryKey), ...commercial };
+      return { id: s.id, label: s.label, ...display, categoryKey: s.categoryKey, price: this.priceFor(s.categoryKey), ...commercial };
     }
     const chosen = tiers.find((t2) => t2.id === this.seatTiers.get(s.id)) ?? tiers[0];
     return {
       id: s.id,
       label: s.label,
+      ...display,
       categoryKey: s.categoryKey,
       price: chosen.price,
       tiers,
@@ -5868,9 +6454,9 @@ function generateSeatThumb(seat, focalPoint, _neighborSeats) {
 
 // src/i18n/bundles.ts
 var LOADERS = {
-  es: () => import("./es-N73CIVTC.js").then((m) => ({ default: m.es })),
-  de: () => import("./de-DRWMZ2FV.js").then((m) => ({ default: m.de })),
-  fr: () => import("./fr-SOY2OB4P.js").then((m) => ({ default: m.fr }))
+  es: () => import("./es-SKAODLTR.js").then((m) => ({ default: m.es })),
+  de: () => import("./de-73TIXYJH.js").then((m) => ({ default: m.de })),
+  fr: () => import("./fr-J4637T6V.js").then((m) => ({ default: m.fr }))
 };
 var loaded = /* @__PURE__ */ new Set(["en"]);
 async function loadLocale(code) {
@@ -5899,6 +6485,7 @@ export {
   MAX_EVENT_INVENTORY,
   MAX_GA_CAPACITY,
   PickerController,
+  RENDERED_QUALITY_REPORT_VERSION,
   SUPPORTED_LOCALES,
   SeatmapRenderer,
   UNGROUPED_ID,
@@ -5926,6 +6513,7 @@ export {
   generateSeatThumb,
   getLocale,
   hiddenObjectIds,
+  inspectRenderedQualityEvidence,
   isGaUnitLabel,
   isSectionHidden,
   layerOf,
@@ -5935,6 +6523,8 @@ export {
   pointInPolygonWithHoles,
   polygonLabelPoint,
   resolveLocale,
+  rowSeatPositions,
+  seatLabelPart,
   setLocale,
   setMoneyLocale,
   setStringOverrides,