@expofp/floorplan 0.0.0-experimental.2d6c681

package/dist/esm/components/Maplibre/utils/venue-pin-rasterize.js

@@ -0,0 +1,220 @@
+import { Box } from '@expofp/geometry';
+import { loadImage } from '../../../utils/loadImage';
+/**
+ * Rasterization of an authored venue pin layer (KTD-5): the designer's plan
+ * layer artwork is serialized to a standalone SVG, rasterized through an
+ * `<img>` (the outdoor-POI `loadImage` → canvas → `map.addImage` pipeline),
+ * and rendered as a screen-fixed MapLibre symbol at the artwork's resolved
+ * bottom-center anchor. Pure helpers and the DOM/canvas path are unit-tested.
+ *
+ * The layer's SVG is fpsync2's compiled output, not the authored drawing: a
+ * vector shape survives only as a `<path data-index>` stub carrying its fill,
+ * with the geometry moved to the layer's mesh table (strokes already outlined
+ * into meshes of their own). The rasterizer rebuilds each stub's `d` from its
+ * mesh before decoding, and leaves everything else — `<image>` children in
+ * particular — to the `<img>` pipeline as authored.
+ */
+/** CSS width of a rasterized venue pin icon (the POI markers use 42). */
+export const VENUE_PIN_WIDTH_PX = 42;
+/**
+ * Icon pixel size for artwork with the given plan-local bounds, scaled to the
+ * target width with the aspect ratio preserved. Null for degenerate bounds.
+ */
+export function venuePinIconSize(bounds, targetWidthPx) {
+    const { width, height } = bounds.size;
+    if (!(width > 0) || !(height > 0))
+        return null;
+    return {
+        width: targetWidthPx,
+        height: Math.max(1, Math.round((targetWidthPx * height) / width)),
+    };
+}
+const positionPoint = (position) => Array.isArray(position) && Number.isFinite(position[0]) && Number.isFinite(position[1])
+    ? // abs(y) mirrors getTrianglesFromFpPaths (data/svg.ts), which the plan
+        // renderer draws every other layer's meshes through.
+        { x: position[0], y: Math.abs(position[1]) }
+    : null;
+/** The mesh's triangles in plan coordinates; empty when it has none to draw. */
+function meshTriangles(mesh) {
+    if (!mesh || !Array.isArray(mesh.positions) || !Array.isArray(mesh.cells))
+        return [];
+    const points = mesh.positions.map(positionPoint);
+    const triangles = [];
+    for (const cell of mesh.cells) {
+        const triangle = Array.isArray(cell) && cell.length === 3 ? cell.map((i) => points[i]) : [];
+        if (triangle.length !== 3 || triangle.some((point) => !point))
+            return [];
+        triangles.push(triangle);
+    }
+    return triangles;
+}
+const formatCoordinate = (value) => String(Math.round(value * 1000) / 1000);
+/**
+ * SVG path data tracing a triangulated mesh's outline: its triangles are wound
+ * one way, every edge two of them share cancels, and what is left — the
+ * boundary — is chained into closed loops. Under the default nonzero fill the
+ * loops paint exactly the triangles' union (the winding number is a sum over
+ * edges, so a hole's loop runs the other way and stays empty), but with no
+ * interior edge for anti-aliasing to leave a hairline seam along — which
+ * painting triangles one at a time does, visibly so at 42 px. Null when the
+ * mesh draws nothing.
+ */
+export function meshPathData(mesh) {
+    return outlinePathData(meshTriangles(mesh));
+}
+function outlinePathData(triangles) {
+    // Keyed by formatted coordinates: a vertex repeated under two indices is
+    // still one vertex, and the output carries exactly these strings.
+    const key = (point) => `${formatCoordinate(point.x)} ${formatCoordinate(point.y)}`;
+    const edges = new Map();
+    const edgeCount = (from, to) => edges.get(from)?.get(to) ?? 0;
+    const setEdgeCount = (from, to, count) => {
+        const outgoing = edges.get(from) ?? new Map();
+        if (count)
+            outgoing.set(to, count);
+        else
+            outgoing.delete(to);
+        if (outgoing.size)
+            edges.set(from, outgoing);
+        else
+            edges.delete(from);
+    };
+    for (const [a, b, c] of triangles) {
+        const area = (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
+        const loop = (area > 0 ? [a, b, c] : [a, c, b]).map(key);
+        if (!area || new Set(loop).size !== 3)
+            continue;
+        for (let index = 0; index < 3; index++) {
+            const from = loop[index];
+            const to = loop[(index + 1) % 3];
+            const reverse = edgeCount(to, from);
+            if (reverse)
+                setEdgeCount(to, from, reverse - 1);
+            else
+                setEdgeCount(from, to, edgeCount(from, to) + 1);
+        }
+    }
+    // Every vertex has as many boundary edges in as out, so a walk from any
+    // vertex can only get stuck back where it started.
+    const loops = [];
+    for (let start = edges.keys().next(); !start.done; start = edges.keys().next()) {
+        const vertices = [start.value];
+        let current = start.value;
+        for (;;) {
+            const next = edges.get(current)?.keys().next();
+            if (!next || next.done)
+                break;
+            setEdgeCount(current, next.value, edgeCount(current, next.value) - 1);
+            current = next.value;
+            if (current === start.value)
+                break;
+            vertices.push(current);
+        }
+        if (vertices.length >= 3)
+            loops.push(`M${vertices.join('L')}Z`);
+    }
+    return loops.length ? loops.join('') : null;
+}
+/**
+ * A copy of a compiled layer group whose `<path data-index>` stubs carry their
+ * mesh geometry again, plus the plan-space extent of those meshes (null when
+ * the layer has none — an image-only layer). Rebuilt paths paint their fill
+ * only: the mesh is already the shape's whole appearance, outlined strokes
+ * included, and its coordinates are final plan coordinates, so a leftover
+ * stroke or transform on the stub would draw it twice or move it. Paths
+ * without a mesh, and every other element, are kept as they are.
+ */
+export function restoreMeshPaths(group, getMesh) {
+    const restored = group.cloneNode(true);
+    const meshPoints = [];
+    for (const path of restored.querySelectorAll('path[data-index]')) {
+        const index = Number(path.getAttribute('data-index'));
+        const triangles = meshTriangles(Number.isInteger(index) && index >= 0 ? getMesh(index) : undefined);
+        const d = outlinePathData(triangles);
+        if (!d)
+            continue;
+        path.setAttribute('d', d);
+        path.removeAttribute('transform');
+        path.style.setProperty('stroke', 'none');
+        meshPoints.push(...triangles.flat());
+    }
+    return { group: restored, meshBounds: meshPoints.length ? Box.fromPoints(meshPoints) : null };
+}
+/**
+ * The plan-space frame to rasterize: the layer rect grown to the meshes'
+ * extent. The rect is computed without stroke, so an outlined stroke pokes
+ * past it; the meshes alone are never the frame, because an image-only layer
+ * has none.
+ */
+export function venuePinFrame(bounds, meshBounds) {
+    return meshBounds ? Box.fromUnion(bounds, meshBounds) : bounds.clone();
+}
+/** Whether a bitmap draws anything: at least one pixel with non-zero alpha. */
+export function hasOpaquePixel(rgba) {
+    for (let index = 3; index < rgba.length; index += 4) {
+        if (rgba[index] !== 0)
+            return true;
+    }
+    return false;
+}
+/**
+ * Wraps serialized plan-layer markup in a standalone SVG document whose
+ * viewBox is the artwork's plan-local bounds, so the group's own coordinates
+ * render unchanged. Class-driven fills are already inlined as style attributes
+ * by the plan SVG parser (data/svg.ts), so no stylesheet needs embedding.
+ */
+export function buildStandaloneSvg(groupMarkup, bounds, width, height) {
+    const { min, size } = bounds;
+    return (`<svg xmlns="http://www.w3.org/2000/svg" ` +
+        `viewBox="${min.x} ${min.y} ${size.width} ${size.height}" ` +
+        `width="${width}" height="${height}">${groupMarkup}</svg>`);
+}
+/**
+ * Rasterizes an authored pin layer's SVG group to a canvas sized for a
+ * screen-fixed marker icon (at `pixelRatio` density; register with
+ * `map.addImage(..., { pixelRatio })` to restore the CSS size). The rect sets
+ * the scale — its width maps to `targetWidthPx` — and the frame grows past it
+ * where meshes do (see {@link venuePinFrame}). Resolves null when the bounds
+ * are degenerate or the browser fails to decode the SVG — the caller keeps
+ * the procedural pin rather than throwing. A successful decode can still be
+ * blank; checking the pixels is the caller's job, since it reads them anyway.
+ */
+export async function rasterizeVenuePinLayer(group, bounds, targetWidthPx, pixelRatio, getMesh) {
+    try {
+        const iconSize = venuePinIconSize(bounds, targetWidthPx);
+        if (!iconSize)
+            return null;
+        const restored = restoreMeshPaths(group, getMesh);
+        const frame = venuePinFrame(bounds, restored.meshBounds);
+        const scale = targetWidthPx / bounds.size.width;
+        const cssWidth = frame.size.width * scale;
+        const cssHeight = frame.size.height * scale;
+        const anchorX = (bounds.center.x - frame.min.x) * scale;
+        const anchorY = (bounds.max.y - frame.min.y) * scale;
+        const iconOffset = [
+            roundOffset(cssWidth / 2 - anchorX),
+            roundOffset(cssHeight - anchorY),
+        ];
+        const width = Math.max(1, Math.round(cssWidth * pixelRatio));
+        const height = Math.max(1, Math.round(cssHeight * pixelRatio));
+        const markup = new XMLSerializer().serializeToString(restored.group);
+        const svg = buildStandaloneSvg(markup, frame, width, height);
+        const image = await loadImage(`data:image/svg+xml;charset=utf-8,${encodeURIComponent(svg)}`);
+        if (!image)
+            return null;
+        const canvas = document.createElement('canvas');
+        canvas.width = width;
+        canvas.height = height;
+        const context = canvas.getContext('2d');
+        if (!context)
+            return null;
+        context.drawImage(image, 0, 0, width, height);
+        return { canvas, iconOffset };
+    }
+    catch (error) {
+        console.warn('rasterizeVenuePinLayer: rasterization failed', error);
+        return null;
+    }
+}
+/** Sub-pixel offsets are noise from float plan coordinates; `+ 0` drops `-0`. */
+const roundOffset = (value) => Math.round(value * 100) / 100 + 0;

package/dist/esm/components/Maplibre/utils/venue-projection.d.ts

@@ -0,0 +1,37 @@
+import { type Box } from '@expofp/geometry';
+import type { GpsConfig } from '../../../utils/gps.js';
+/** Plan-local units to ground metres, using the same p0/p2 anchor pair as plan rendering. */
+export declare function getMetersPerLocalUnit(gpsConfig: GpsConfig | null | undefined): number;
+/** Web Mercator ground resolution at a latitude and map zoom, in metres per CSS pixel. */
+export declare function getWebMercatorMetersPerCssPixel(latitude: number, zoom: number): number;
+/**
+ * The camera-invariant half of {@link getVenueSizePx}: the venue footprint in
+ * ground metres and the latitude its Web Mercator scale is read at. Both depend
+ * only on the venue bounds and the plan's GPS anchors, so callers on the camera
+ * path resolve this once per venue instead of per frame.
+ */
+export interface VenueGroundFootprint {
+    /** Smaller ground-plane footprint dimension, in metres. */
+    minSizeMeters: number;
+    /** Latitude of the venue centroid. */
+    centroidLatitude: number;
+}
+/** Projects a venue's plan-local bounds onto the ground plane, or null when unusable. */
+export declare function getVenueGroundFootprint(bounds: Box, gpsConfig: GpsConfig | null | undefined): VenueGroundFootprint | null;
+/** Ground footprint in CSS pixels at one map zoom. */
+export declare function getFootprintSizePx(footprint: VenueGroundFootprint | null, zoom: number): number | null;
+/**
+ * The zoom at which a footprint measures `sizePx` — the exact inverse of
+ * {@link getFootprintSizePx}, kept beside it so the two cannot drift.
+ *
+ * Turns an authored pixel threshold back into the camera position it takes
+ * effect at, which is the only form an author can check against the map (§12
+ * Guard 5).
+ */
+export declare function getZoomForFootprintSizePx(footprint: VenueGroundFootprint | null, sizePx: number): number | null;
+/**
+ * Smaller ground-plane footprint dimension in CSS pixels. Camera bearing and
+ * pitch cannot affect this API or calculation.
+ */
+export declare function getVenueSizePx(bounds: Box, gpsConfig: GpsConfig | null | undefined, zoom: number): number | null;
+//# sourceMappingURL=venue-projection.d.ts.map

package/dist/esm/components/Maplibre/utils/venue-projection.js

@@ -0,0 +1,88 @@
+import { degToRad, haversineDistance, pointDistance, projectLocalToGps, } from '@expofp/geometry';
+import { geoAnchors } from '../../../utils/geo-anchors.js';
+// Web Mercator world circumference divided by MapLibre's 512 CSS-pixel tile size.
+const METERS_PER_CSS_PIXEL_AT_ZOOM_0 = 40_075_016.68557849 / 512;
+const isFiniteAnchor = (anchor) => Number.isFinite(anchor.x) &&
+    Number.isFinite(anchor.y) &&
+    Number.isFinite(anchor.lat) &&
+    Number.isFinite(anchor.lng);
+/** Plan-local units to ground metres, using the same p0/p2 anchor pair as plan rendering. */
+export function getMetersPerLocalUnit(gpsConfig) {
+    if (!gpsConfig)
+        return NaN;
+    if (!isFiniteAnchor(gpsConfig.p0) || !isFiniteAnchor(gpsConfig.p2))
+        return NaN;
+    const localDistance = pointDistance(gpsConfig.p0, gpsConfig.p2);
+    const groundDistance = haversineDistance(gpsConfig.p0, gpsConfig.p2);
+    if (!Number.isFinite(localDistance) ||
+        localDistance <= 0 ||
+        !Number.isFinite(groundDistance) ||
+        groundDistance <= 0) {
+        return NaN;
+    }
+    return groundDistance / localDistance;
+}
+/** Web Mercator ground resolution at a latitude and map zoom, in metres per CSS pixel. */
+export function getWebMercatorMetersPerCssPixel(latitude, zoom) {
+    if (!Number.isFinite(latitude) || Math.abs(latitude) >= 90 || !Number.isFinite(zoom))
+        return NaN;
+    return (METERS_PER_CSS_PIXEL_AT_ZOOM_0 * Math.cos(degToRad(latitude))) / Math.pow(2, zoom);
+}
+/** Projects a venue's plan-local bounds onto the ground plane, or null when unusable. */
+export function getVenueGroundFootprint(bounds, gpsConfig) {
+    if (!gpsConfig)
+        return null;
+    const width = bounds.size.width;
+    const height = bounds.size.height;
+    if (!Number.isFinite(width) || width <= 0 || !Number.isFinite(height) || height <= 0)
+        return null;
+    const metersPerLocalUnit = getMetersPerLocalUnit(gpsConfig);
+    if (!Number.isFinite(metersPerLocalUnit) || metersPerLocalUnit <= 0)
+        return null;
+    try {
+        return {
+            minSizeMeters: Math.min(width, height) * metersPerLocalUnit,
+            centroidLatitude: projectLocalToGps(bounds.center, ...geoAnchors(gpsConfig)).lat,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/** Ground footprint in CSS pixels at one map zoom. */
+export function getFootprintSizePx(footprint, zoom) {
+    if (!footprint)
+        return null;
+    const metersPerCssPixel = getWebMercatorMetersPerCssPixel(footprint.centroidLatitude, zoom);
+    if (!Number.isFinite(metersPerCssPixel) || metersPerCssPixel <= 0)
+        return null;
+    const sizePx = footprint.minSizeMeters / metersPerCssPixel;
+    return Number.isFinite(sizePx) && sizePx >= 0 ? sizePx : null;
+}
+/**
+ * The zoom at which a footprint measures `sizePx` — the exact inverse of
+ * {@link getFootprintSizePx}, kept beside it so the two cannot drift.
+ *
+ * Turns an authored pixel threshold back into the camera position it takes
+ * effect at, which is the only form an author can check against the map (§12
+ * Guard 5).
+ */
+export function getZoomForFootprintSizePx(footprint, sizePx) {
+    if (!footprint || !Number.isFinite(sizePx) || sizePx <= 0)
+        return null;
+    const { minSizeMeters, centroidLatitude } = footprint;
+    if (!Number.isFinite(minSizeMeters) || minSizeMeters <= 0)
+        return null;
+    const metersPerCssPixelAtZoom0 = getWebMercatorMetersPerCssPixel(centroidLatitude, 0);
+    if (!Number.isFinite(metersPerCssPixelAtZoom0) || metersPerCssPixelAtZoom0 <= 0)
+        return null;
+    const zoom = Math.log2((sizePx * metersPerCssPixelAtZoom0) / minSizeMeters);
+    return Number.isFinite(zoom) ? zoom : null;
+}
+/**
+ * Smaller ground-plane footprint dimension in CSS pixels. Camera bearing and
+ * pitch cannot affect this API or calculation.
+ */
+export function getVenueSizePx(bounds, gpsConfig, zoom) {
+    return getFootprintSizePx(getVenueGroundFootprint(bounds, gpsConfig), zoom);
+}

package/dist/esm/components/Maplibre/utils/venue-tap-hit-test.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Model-space hit-test against the degraded-venue tap targets (the invisible
+ * contour fill and the pin/label symbols), set by `useVenueLayers` while active
+ * (KTD-6). The plan's click seam (`clickedPlan` in Map/pointer.ts) consults it
+ * so a tap that focuses a degraded venue does not also select a hidden booth
+ * underneath — booth hit-testing is geometric and ignores `LayerDef.hidden`.
+ */
+export declare const venueTapHitTest: import("./hit-test-registry.js").HitTestRegistry;
+//# sourceMappingURL=venue-tap-hit-test.d.ts.map

package/dist/esm/components/Maplibre/utils/venue-tap-hit-test.js

@@ -0,0 +1,9 @@
+import { createHitTestRegistry } from './hit-test-registry.js';
+/**
+ * Model-space hit-test against the degraded-venue tap targets (the invisible
+ * contour fill and the pin/label symbols), set by `useVenueLayers` while active
+ * (KTD-6). The plan's click seam (`clickedPlan` in Map/pointer.ts) consults it
+ * so a tap that focuses a degraded venue does not also select a hidden booth
+ * underneath — booth hit-testing is geometric and ignores `LayerDef.hidden`.
+ */
+export const venueTapHitTest = createHitTestRegistry();

package/dist/esm/components/Maplibre/utils/venue-viewport-detail.d.ts

@@ -0,0 +1,19 @@
+import type { Map as MaplibreMap } from 'maplibre-gl';
+import type { Venue } from '../../../store/VenueStore';
+import { type GeoConfig } from './geo-config';
+import { type VenueGroundFootprint } from './venue-projection';
+/**
+ * The venue's on-screen size where its floors fit the map's current viewport,
+ * framed with the same padding `fitMapToLocalRect` uses — the size the detail
+ * cutoff is lowered to on screens too small for the authored cutoff.
+ */
+export declare function getViewportFitSizePx(map: MaplibreMap, geoConfig: GeoConfig, venue: Venue, footprint?: VenueGroundFootprint | null): number | null;
+/**
+ * A venue's detail cutoff on the map's current viewport: the authored cutoff,
+ * lowered to the venue's size where its floors fit the visible area (see
+ * {@link resolveViewportDetailThreshold}). Venue entry, booth focus and the
+ * presentation tracker all read the cutoff here, so a camera fitted to a floor
+ * lands exactly where that floor's detail begins.
+ */
+export declare function getViewportDetailThreshold(map: MaplibreMap, geoConfig: GeoConfig, venue: Venue, footprint?: VenueGroundFootprint | null): number;
+//# sourceMappingURL=venue-viewport-detail.d.ts.map

package/dist/esm/components/Maplibre/utils/venue-viewport-detail.js

@@ -0,0 +1,24 @@
+import { detailMinSizeFloor } from '../../../data/venues';
+import { cameraForLocalRect, DEFAULT_FIT_PADDING, getVisibleRectFitPadding, venueLevelBearing, } from './geo-config';
+import { resolveDetailThreshold, resolveMarkerThreshold, resolveViewportDetailThreshold, } from './venue-legibility';
+import { getFootprintSizePx, getVenueGroundFootprint, } from './venue-projection';
+/**
+ * The venue's on-screen size where its floors fit the map's current viewport,
+ * framed with the same padding `fitMapToLocalRect` uses — the size the detail
+ * cutoff is lowered to on screens too small for the authored cutoff.
+ */
+export function getViewportFitSizePx(map, geoConfig, venue, footprint = getVenueGroundFootprint(venue.bounds, geoConfig.gpsConfig)) {
+    const canvas = map.getCanvas();
+    const fit = cameraForLocalRect(venue.frame, geoConfig.gpsConfig, venueLevelBearing(geoConfig, venue.activeLevel.layer.name), { width: canvas.clientWidth, height: canvas.clientHeight }, getVisibleRectFitPadding(DEFAULT_FIT_PADDING));
+    return fit ? getFootprintSizePx(footprint, fit.zoom) : null;
+}
+/**
+ * A venue's detail cutoff on the map's current viewport: the authored cutoff,
+ * lowered to the venue's size where its floors fit the visible area (see
+ * {@link resolveViewportDetailThreshold}). Venue entry, booth focus and the
+ * presentation tracker all read the cutoff here, so a camera fitted to a floor
+ * lands exactly where that floor's detail begins.
+ */
+export function getViewportDetailThreshold(map, geoConfig, venue, footprint = getVenueGroundFootprint(venue.bounds, geoConfig.gpsConfig)) {
+    return resolveViewportDetailThreshold(resolveDetailThreshold(venue.detailMinSizePx), getViewportFitSizePx(map, geoConfig, venue, footprint), detailMinSizeFloor(resolveMarkerThreshold(venue.markerMaxSizePx)));
+}

package/dist/esm/components/Maplibre/utils/venue-zoom.d.ts

@@ -0,0 +1,23 @@
+import type { ParsedVenueAuxLayer } from '../../../data/venues.js';
+import { type StickySizeEdgeState } from './venue-legibility.js';
+export interface VenuePresentationConfig {
+    detailMinSizePx?: number;
+    /** The venue's marker ⇄ scene edge (§4, Revision 5); absent means the default 60. */
+    markerMaxSizePx?: number;
+    auxLayers: readonly ParsedVenueAuxLayer[];
+}
+export interface VenuePresentationState {
+    detailVisible: boolean;
+    visibleAuxLayers: string[];
+    fallbackSceneVisible: boolean;
+    fallbackMarkerVisible: boolean;
+    stickyEdges: {
+        markerScene: StickySizeEdgeState;
+        detail: StickySizeEdgeState;
+    };
+}
+/** Pure Revision 2 marker/scene/detail resolution on one CSS-pixel size axis. */
+export declare function resolveVenuePresentationState(config: VenuePresentationConfig, measuredSizePx: number | null, previous: VenuePresentationState | null): VenuePresentationState;
+/** Structural equality used to avoid redundant observable writes on camera frames. */
+export declare function venuePresentationStatesEqual(a: VenuePresentationState, b: VenuePresentationState): boolean;
+//# sourceMappingURL=venue-zoom.d.ts.map

package/dist/esm/components/Maplibre/utils/venue-zoom.js

@@ -0,0 +1,62 @@
+import { resolveDetailThreshold, resolveMarkerThreshold, resolveStickySizeEdge, } from './venue-legibility.js';
+const validSize = (sizePx) => sizePx !== null && Number.isFinite(sizePx) && sizePx >= 0;
+function layerVisible(layer, sizePx, markerScene, detail) {
+    const aboveMin = layer.minSizePx !== undefined
+        ? sizePx >= layer.minSizePx
+        : layer.render === 'marker' || markerScene === 'above';
+    const belowMax = typeof layer.maxSizePx === 'number'
+        ? sizePx <= layer.maxSizePx
+        : layer.maxSizePx === 'detail' || layer.render === 'scene'
+            ? detail === 'below'
+            : markerScene === 'below';
+    return aboveMin && belowMax;
+}
+/** Pure Revision 2 marker/scene/detail resolution on one CSS-pixel size axis. */
+export function resolveVenuePresentationState(config, measuredSizePx, previous) {
+    const sizePx = validSize(measuredSizePx) ? measuredSizePx : 0;
+    const previousMarkerScene = validSize(measuredSizePx)
+        ? (previous?.stickyEdges.markerScene ?? null)
+        : null;
+    const previousDetail = validSize(measuredSizePx) ? (previous?.stickyEdges.detail ?? null) : null;
+    const detailThreshold = resolveDetailThreshold(config.detailMinSizePx);
+    const markerThreshold = resolveMarkerThreshold(config.markerMaxSizePx);
+    const markerScene = resolveStickySizeEdge(measuredSizePx, markerThreshold, previousMarkerScene);
+    const detail = resolveStickySizeEdge(measuredSizePx, detailThreshold, previousDetail);
+    const visibleAuxLayers = [
+        ...new Set(config.auxLayers
+            .filter((layer) => layerVisible(layer, sizePx, markerScene, detail))
+            .map((layer) => layer.layer)),
+    ];
+    // Suppression is scoped to where a replacing layer is visible, not to the render
+    // mode's whole default band: narrowing an authored range reverts to the procedural
+    // appearance outside it instead of drawing nothing (ADR-0005).
+    //
+    // Each fallback asks that question at the size clamped into the band it would draw
+    // in. Band edges are sticky while an authored numeric bound is hard, so inside a
+    // hysteresis dead-zone the raw size can sit outside a bound that was written at the
+    // band edge — §7's own worked example spells out `60` on both layers — while the
+    // fallback for that band is still the one being drawn. Clamping keeps the two edges
+    // agreeing, so no procedural artwork blinks in mid-band.
+    const replaces = (render, bandSizePx) => config.auxLayers.some((layer) => layer.render === render &&
+        layer.replacesDefault &&
+        layerVisible(layer, bandSizePx, markerScene, detail));
+    const replacesMarker = replaces('marker', Math.min(sizePx, markerThreshold));
+    const replacesScene = replaces('scene', Math.min(Math.max(sizePx, markerThreshold), detailThreshold));
+    return {
+        detailVisible: detail === 'above',
+        visibleAuxLayers,
+        fallbackSceneVisible: markerScene === 'above' && detail === 'below' && !replacesScene,
+        fallbackMarkerVisible: markerScene === 'below' && !replacesMarker,
+        stickyEdges: { markerScene, detail },
+    };
+}
+/** Structural equality used to avoid redundant observable writes on camera frames. */
+export function venuePresentationStatesEqual(a, b) {
+    return (a.detailVisible === b.detailVisible &&
+        a.fallbackSceneVisible === b.fallbackSceneVisible &&
+        a.fallbackMarkerVisible === b.fallbackMarkerVisible &&
+        a.stickyEdges.markerScene === b.stickyEdges.markerScene &&
+        a.stickyEdges.detail === b.stickyEdges.detail &&
+        a.visibleAuxLayers.length === b.visibleAuxLayers.length &&
+        a.visibleAuxLayers.every((name, index) => name === b.visibleAuxLayers[index]));
+}

package/dist/esm/components/Menu.d.ts

@@ -0,0 +1,11 @@
+import { type Consent } from '@expofp/config';
+import React from 'react';
+import './Menu.scss';
+import './Menu_custom.scss';
+interface MenuProps {
+    isGDPR: boolean;
+    consent: Consent;
+}
+export default _default;
+declare function _default({ isGDPR, consent }: MenuProps): React.JSX.Element;
+//# sourceMappingURL=Menu.d.ts.map

package/dist/esm/components/Menu.js

@@ -0,0 +1,94 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Badge } from '@expofp/ui';
+import { useLocalStore, useObserver } from 'mobx-react-lite';
+import React, { Suspense } from 'react';
+import data from '../data';
+import { getFpSvgJs } from '../data/fp-payloads';
+import store, { uiState } from '../store';
+import { getLocale, getLocales, t } from '../utils/i18n';
+import isIframe from '../utils/is-iframe';
+import { useAutorun } from '../utils/mobx.js';
+const ViewerMenuPanel = React.lazy(() => import(/* webpackChunkName: "viewer-menu-panel" */ './ViewerMenuPanel'));
+import './Menu.scss';
+import './Menu_custom.scss';
+import logger from '../tools/logger';
+import settings from '../tools/settings';
+// Warm the browser cache for the logo (already resolved by @expofp/config,
+// incl. the historical fallback logos). Registered once, on the first plan
+// only — the URL is read when the timer fires rather than captured here, but
+// nothing re-arms it for a later plan; the <img> below is what forwards.
+window.setTimeout(function () {
+    const img = new Image();
+    img.onload = () => {
+        logger.log('Logo image loaded');
+    };
+    img.crossOrigin = 'anonymous';
+    img.src = data.logo;
+}, 1500);
+function Menu({ consent, isGDPR }) {
+    const s = useLocalStore(() => ({
+        logoVisibility: 'visible',
+        shown: false,
+        shownTimeout: undefined,
+        modalOpen: false,
+        selectedCategoryIds: (uiState.selectedCategoryFilters || []).map((c) => Number(c.id)),
+        pendingSelectedIds: (uiState.selectedCategoryFilters || []).map((c) => Number(c.id)),
+    }));
+    // One autorun per mounted menu, disposed on unmount — created in render it
+    // stacked a fresh one every re-render and outlived the plan.
+    useAutorun(() => {
+        if (!uiState.menu) {
+            s.shown = false;
+            if (s.shownTimeout)
+                window.clearTimeout(s.shownTimeout);
+        }
+        else {
+            s.shownTimeout = window.setTimeout(() => (s.shown = true), 1);
+            if (uiState.list.type === 'sessions') {
+                store.searchStore.selectSearch();
+            }
+        }
+    });
+    function handleClick(e) {
+        if (uiState.kiosk)
+            return e.preventDefault();
+    }
+    function handleSearch(e) {
+        e.preventDefault();
+        close();
+        store.searchStore.selectSearch();
+    }
+    function handleLeaveEvent(e) {
+        e.preventDefault();
+        store.fp?.onLeaveEvent?.();
+    }
+    function handleLanguage(e) {
+        e.preventDefault();
+        store.clickLanguage();
+    }
+    return useObserver(() => {
+        if (!uiState.menu)
+            return null;
+        const bookmarks = store.boothStore.booths
+            .filter((b) => b.bookmarked)
+            .map((b) => b.name);
+        const pdfUrl = getFpSvgJs().__fpSettings?.fpVer
+            ? `https://d2.expofp.com/export/v2/${settings.EXPO}/pdf`
+            : `https://api.expofp.com/service/convert/${settings.EXPO}/pdf`;
+        const canLeaveEvent = uiState.viewerMode && typeof store.fp?.onLeaveEvent === 'function';
+        return (_jsxs("div", { className: `menu ${s.shown ? 'shown' : ''}`, children: [isIframe ? (_jsx("div", { className: "menu__cover -empty" })) : (_jsx("div", { className: "menu__cover", children: _jsx("a", { href: data.homeUrl, target: "_blank", rel: "noopener noreferrer", onClick: handleClick, children: _jsx("img", { src: data.logo, onError: () => (s.logoVisibility = 'hidden'), style: { visibility: s.logoVisibility }, alt: "", crossOrigin: "anonymous" }) }) })), _jsxs("div", { className: "menu__content", children: [uiState.viewerMode && (_jsx(Suspense, { fallback: null, children: _jsx(ViewerMenuPanel, {}) })), !uiState.viewerMode && (_jsx("a", { href: "/#", onClick: handleSearch, className: "menu__item", children: t('Search') })), !data.hideEventHomeLink && !uiState.kiosk && !isIframe && !!data.homeUrl && (_jsxs("a", { href: data.homeUrl, target: "_blank", className: "menu__item", rel: "noopener noreferrer", children: [t('Event Home').replace(/ /g, '\u00A0'), _jsx("i", { className: "icon-link-external" })] })), !data.hideRegisterToAttendLink && !uiState.kiosk && !isIframe && !!data.registerUrl && (_jsxs("a", { href: data.registerUrl, target: "_blank", className: "menu__item", rel: "noopener noreferrer", children: [t('Register to Attend').replace(/ /g, '\u00A0'), _jsx("i", { className: "icon-link-external" })] })), !uiState.hideLanguage &&
+                            !data.hideLanguage &&
+                            !data.hideLanguageLink &&
+                            getLocales().length > 1 && (_jsxs("a", { href: "?language", onClick: handleLanguage, className: "menu__item -language", children: [_jsxs("span", { children: [t('Language'), " "] }), _jsxs("span", { className: "menu__icons", children: [_jsx(Badge, { variant: "gray", size: "md", noMargins: true, rounded: true, children: getLocales().find((lang) => lang.id === getLocale())?.name }), _jsx("i", { className: "icon-chevron-right" })] })] })), !data.hideDownloadPdfLink && !uiState.kiosk && (_jsx("a", { className: "menu__item -pdf", target: "_blank", rel: "noopener noreferrer", href: `${pdfUrl}/?exhibitors=true&bookmarks=${bookmarks.join(',')}&layers=${(store
+                                .layerStore.layers.length >= store.layerStore.visible.length
+                                ? store.layerStore.visible.map((l) => l.name).join(',')
+                                : '').replace(/&/g, '%26')}`, children: t('Download PDF') })), consent === 'ask' && isGDPR && (_jsx("a", { href: "/#", className: "menu__item -cookie-consent", onClick: (e) => {
+                                e.preventDefault();
+                                uiState.hideCookieConsent = false;
+                            }, children: t('Review Cookie Consent') })), canLeaveEvent && (_jsx("div", { className: "menu__item-leave", children: _jsx("a", { href: "/#", className: "menu__item -leave-event menu__leave-link", onClick: handleLeaveEvent, children: t('Select another event') }) }))] })] }));
+    });
+    function close() {
+        uiState.menu = false;
+    }
+}
+export default ({ isGDPR, consent }) => useObserver(() => _jsx(_Fragment, { children: uiState.menu ? _jsx(Menu, { isGDPR: isGDPR, consent: consent }) : null }));

package/dist/esm/components/MobileToggleButtonContainer.d.ts

@@ -0,0 +1,3 @@
+declare function MobileToggleButtonContainer(): import("react").JSX.Element | null;
+export default MobileToggleButtonContainer;
+//# sourceMappingURL=MobileToggleButtonContainer.d.ts.map

package/dist/esm/components/MobileToggleButtonContainer.js

@@ -0,0 +1,24 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { MobileToggleButton } from '@expofp/ui';
+import { useObserver } from 'mobx-react-lite';
+import { useCallback } from 'react';
+import { searchStore, uiState } from '../store';
+import { t } from '../utils/i18n';
+function MobileToggleButtonContainer() {
+    const handleToggleClick = useCallback(() => {
+        if (uiState.isOverlayOpen && uiState.overlaySize === 'full') {
+            uiState.desiredOverlaySize = 'small';
+        }
+        else {
+            searchStore.openOverlayWithoutInputFocus();
+        }
+    }, []);
+    return useObserver(() => {
+        if (!uiState.shouldShowMobileToggle) {
+            return null;
+        }
+        const isListMode = uiState.mobileToggleIsListMode;
+        return (_jsx(MobileToggleButton, { mode: isListMode ? 'list' : 'map', label: isListMode ? t('List') : t('Map'), ariaLabel: isListMode ? t('Show list') : t('Show map'), onClick: handleToggleClick }));
+    });
+}
+export default MobileToggleButtonContainer;