@expofp/floorplan 0.0.0-experimental.2d6c681

package/dist/esm/constants.js

@@ -0,0 +1,66 @@
+export const VISIBILITY_STORAGE_KEY = '___visibility';
+export const PREVIEW_MODE_ATTRIBUTE = 'data-preview-mode';
+// Class of the loader that `load()` draws in a host element it created itself.
+export const RUNTIME_LOADER_SPINNER_CLASS = 'efp-runtime-loader-spinner';
+export const BOOTHS_PAINTER_MARKER = 'booths';
+export const SEPARATOR = ':';
+// Designer layers whose name starts with this prefix (case-insensitive) hold
+// "outdoor" PoI (hotels, parking, transit). Their icons render at a fixed
+// on-screen size in the geo map, independent of zoom — they are markers, not
+// physical objects. Indoor booths and all other layers are unaffected.
+// Set this to the prefix you standardize on in the designer.
+export const OUTDOOR_LAYER_PREFIX = 'Outdoor';
+// Outdoor PoI markers within this many pixels of each other merge into a
+// cluster bubble (MapLibre GeoJSON-source clustering). TODO(poi): make configurable.
+export const POI_CLUSTER_RADIUS_PX = 50;
+// Match Mapbox source clustering defaults used by the outdoor-only app:
+// pairs stay as individual pins, 3+ nearby points collapse into a cluster.
+export const POI_CLUSTER_MIN_POINTS = 3;
+// Outdoor PoI pin sizes: the visible pin width, drop shadow excluded (the
+// vector shapes live in Map/drawing/config/poi-pin-shape.ts).
+// Matches the outdoor-only app's category pins (~40x46px).
+export const POI_MARKER_PIN_WIDTH_PX = 40;
+// The outdoor-only app draws its selected pin as wide as the category pin.
+export const POI_SELECTED_PIN_WIDTH_PX = POI_MARKER_PIN_WIDTH_PX;
+export const POI_PIN_DEFAULT_COLOR = '#ea4236';
+export const POI_CLUSTER_SIZE_PX = 36;
+export const POI_CLUSTER_COLOR = 'rgba(234, 66, 54, 0.85)';
+export const POI_CLUSTER_STROKE_COLOR = '#ffffff';
+export const POI_CLUSTER_STROKE_WIDTH_PX = 2;
+export const POI_CLUSTER_TEXT_SIZE_PX = 14;
+export const LAYER_LOGOS_MARKER = 'logos';
+export const LAYER_ICONS_MARKER = 'icons';
+export const STRING_META_DELIMITER = '$$';
+export const KIOSK_ENABLE_KEY = 'kiosk';
+export const SET_KIOSK_KEY = 'setkiosk';
+export const BOOKMARK_PAINTER_MARKER = 'booth-bookmark';
+export const DEBUG_KEY = 'debug';
+export const DEBUG_STORAGE_KEY = 'efp-debugMode';
+export const DEFAULT_UNITS = 'ft';
+export const PATHWAY_KEY = 'pathway';
+export const CACHE_DURATION = 1000;
+export const MOBILE_BREAKPOINT = 768;
+export const LANGUAGE_TYPE = 'language';
+export const MAX_ROUTE_WAYPOINTS = 8;
+// Sticky per-browser preferences, seeded by the legacy `?viewermode=` /
+// `?previewMode=` / `?uiscale=` URL params. Each key MUST be `efp-` + its
+// `LocalStorageConfigSchema` field name — the config's localStorage codec and
+// the debug panel derive the keys from the schema. Values are the codec's
+// canonical scalar strings: 'true'/'false' for booleans, a stringified float
+// for the scale. The pre-schema `LEGACY_*` keys are still honored as read
+// fallbacks (and migrated forward at boot by `migrateLegacyStorageKeys`);
+// their removal is planned a release or two out.
+export const VIEWER_MODE_STORAGE_KEY = 'efp-viewerMode';
+export const LEGACY_VIEWER_MODE_STORAGE_KEY = '___viewer_mode'; // value '1'
+export const PREVIEW_MODE_STORAGE_KEY = 'efp-previewMode';
+export const LEGACY_PREVIEW_MODE_STORAGE_KEY = '___preview_mode'; // value '1'
+export const UI_SCALE_STORAGE_KEY = 'efp-uiScale';
+export const LEGACY_UI_SCALE_STORAGE_KEY = '___ui-scale';
+// custom css variables
+export const FONT_FACE = '--expofp-font-face';
+export const FONT_WEIGHT_PRIMARY_BOOTH = '--expofp-booth-main-weight';
+export const FONT_WEIGHT_SECONDARY_BOOTH = '--expofp-booth-details-weight';
+export const FONT_WEIGHT_PRIMARY_EXHIBITOR = '--expofp-exhibitor-main-weight';
+export const FONT_WEIGHT_SECONDARY_EXHIBITOR = '--expofp-exhibitor-details-weight';
+export const FONT_WEIGHT_PRIMARY_SPECIAL = '--expofp-booth-special-weight';
+export const ORIENTATION_GRANTED_KEY = 'efp-compass-permission-granted';

package/dist/esm/data/fp-payloads.d.ts

@@ -0,0 +1,27 @@
+import { type FpPath, type FpSvgJs, type WfData } from '@expofp/schema';
+/**
+ * Read access to the legacy drawing/wayfinding payloads behind the config's
+ * refs. The config carries only `$ref`s; `loadConfig` resolved the drawing
+ * (`fpSvgJsRef`) and the graph (`wfDataJsRef`) before the floorplan booted,
+ * and lazy layers are resolved on demand (`config-load-layer.ts`) — this
+ * module reads them all back synchronously from `@expofp/resolve`'s memo.
+ * Payloads settle with every asset URL already absolute (schema-aware
+ * resolution), so these are plain reads.
+ *
+ * The old `window.__fp<layerName>` alias lookups are gone: a layer name maps
+ * to its lazily-resolved payload, or to the eager drawing when it names the
+ * default layer (whose drawing IS `fp.svg.js`). Newer converters emit ONLY
+ * the layer-suffixed globals in layer files (`window['__fpBooth'] = …`), but
+ * the loader folds those onto the canonical `__fp`/`__fpPaths` keys when the
+ * payload resolves (`normalizeFpSvgLayerAliases`, `@expofp/config`) — so
+ * these reads see one canonical shape from either converter generation.
+ */
+/** The eagerly-resolved `fp.svg.js` payload (drawing + plan-wide metadata). */
+export declare function getFpSvgJs(): FpSvgJs;
+/** One layer's SVG document (`''` = the default drawing), asset hrefs resolved. */
+export declare function getFpSvg(layerName?: string): string | undefined;
+/** One layer's triangulated meshes (`''` = the default drawing). */
+export declare function getFpPaths(layerName?: string): FpPath[] | undefined;
+/** The wayfinding graph; `null` while unloaded or when the plan has none. */
+export declare function getWfData(): WfData | null;
+//# sourceMappingURL=fp-payloads.d.ts.map

package/dist/esm/data/fp-payloads.js

@@ -0,0 +1,53 @@
+import { getConfig } from '@expofp/config';
+import { getResolved, isResolved } from '@expofp/resolve';
+/**
+ * Read access to the legacy drawing/wayfinding payloads behind the config's
+ * refs. The config carries only `$ref`s; `loadConfig` resolved the drawing
+ * (`fpSvgJsRef`) and the graph (`wfDataJsRef`) before the floorplan booted,
+ * and lazy layers are resolved on demand (`config-load-layer.ts`) — this
+ * module reads them all back synchronously from `@expofp/resolve`'s memo.
+ * Payloads settle with every asset URL already absolute (schema-aware
+ * resolution), so these are plain reads.
+ *
+ * The old `window.__fp<layerName>` alias lookups are gone: a layer name maps
+ * to its lazily-resolved payload, or to the eager drawing when it names the
+ * default layer (whose drawing IS `fp.svg.js`). Newer converters emit ONLY
+ * the layer-suffixed globals in layer files (`window['__fpBooth'] = …`), but
+ * the loader folds those onto the canonical `__fp`/`__fpPaths` keys when the
+ * payload resolves (`normalizeFpSvgLayerAliases`, `@expofp/config`) — so
+ * these reads see one canonical shape from either converter generation.
+ */
+/** The eagerly-resolved `fp.svg.js` payload (drawing + plan-wide metadata). */
+export function getFpSvgJs() {
+    const ref = getConfig().fpSvgJsRef;
+    if (!ref) {
+        throw new Error('No drawing in the config (fpSvgJsRef is not set)');
+    }
+    return getResolved(ref);
+}
+/** The payload carrying one layer's drawing, if it is resolved yet. */
+function getFpPayload(layerName) {
+    const ref = getConfig().fpSvgLayerJsRefs[layerName];
+    if (ref && isResolved(ref))
+        return getResolved(ref);
+    const fpSvgJs = getFpSvgJs();
+    // '' and the default layer's own name address the eager drawing
+    if (layerName === '' || layerName === fpSvgJs.__fpDefaultLayer)
+        return fpSvgJs;
+    return undefined;
+}
+/** One layer's SVG document (`''` = the default drawing), asset hrefs resolved. */
+export function getFpSvg(layerName = '') {
+    return getFpPayload(layerName)?.__fp;
+}
+/** One layer's triangulated meshes (`''` = the default drawing). */
+export function getFpPaths(layerName = '') {
+    return getFpPayload(layerName)?.__fpPaths;
+}
+/** The wayfinding graph; `null` while unloaded or when the plan has none. */
+export function getWfData() {
+    const ref = getConfig().wfDataJsRef;
+    if (!ref || !isResolved(ref))
+        return null;
+    return getResolved(ref).__wfData ?? null;
+}

package/dist/esm/data/fpGeo.d.ts

@@ -0,0 +1,45 @@
+import { type MapTheme } from '@expofp/schema';
+interface ImageData {
+    layer: string;
+    data: string;
+    points: unknown[][];
+}
+interface GeoAnchorPoint {
+    x: number;
+    y: number;
+    lat: number;
+    lng: number;
+}
+interface FpGeoProperties {
+    config?: {
+        p0: GeoAnchorPoint;
+        p1?: GeoAnchorPoint;
+        p2: GeoAnchorPoint;
+        bearing?: number;
+        snapThreshold?: number;
+        /** Basemap palette the Designer authored the drawing for. */
+        style?: MapTheme;
+        /** `'maplibre'` when the Designer authored the plan for the MapLibre map. */
+        type?: 'maplibre';
+    };
+    mpViewbox?: number[];
+    useMaplibre?: boolean;
+    [key: string]: unknown;
+}
+/**
+ * `__fpGeo` as the SDK reads it: the georeferencing extension of a GeoJSON
+ * FeatureCollection. Only `properties` and `images` are consumed here — the
+ * FeatureCollection part (`type`, `features`) passes through untyped.
+ */
+interface ExtendFeatureCollection {
+    properties: FpGeoProperties;
+    images: ImageData[];
+}
+/**
+ * The live event's georeferencing block, or `undefined` when the drawing has
+ * none. Read through the call — a module-scope capture would pin the previous
+ * plan's geometry across a swap (ADR-0011).
+ */
+export declare function getFpGeo(): ExtendFeatureCollection | undefined;
+export {};
+//# sourceMappingURL=fpGeo.d.ts.map

package/dist/esm/data/fpGeo.js

@@ -0,0 +1,9 @@
+import { getFpSvgJs } from './fp-payloads.js';
+/**
+ * The live event's georeferencing block, or `undefined` when the drawing has
+ * none. Read through the call — a module-scope capture would pin the previous
+ * plan's geometry across a swap (ADR-0011).
+ */
+export function getFpGeo() {
+    return getFpSvgJs().__fpGeo;
+}

package/dist/esm/data/index.d.ts

@@ -0,0 +1,15 @@
+import { type Config } from '@expofp/config';
+/**
+ * The event data document — the merged, asset-resolved, normalized and frozen
+ * copy `loadConfig` produced (it carries every legacy `data.js` field;
+ * `window.__data` is gone).
+ *
+ * Every property read forwards to whatever config is installed *now*, so a
+ * plan swap is visible through this binding without any of its ~38 importers
+ * changing (ADR-0011). Capturing it — `const { title } = data` at module
+ * scope, or stashing the object in a module-level variable — reintroduces the
+ * staleness this indirection exists to remove.
+ */
+declare const data: Config;
+export default data;
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/data/index.js

@@ -0,0 +1,15 @@
+import { getConfig } from '@expofp/config';
+import { createSwappableProxy } from '../utils/swappable-proxy.js';
+/**
+ * The event data document — the merged, asset-resolved, normalized and frozen
+ * copy `loadConfig` produced (it carries every legacy `data.js` field;
+ * `window.__data` is gone).
+ *
+ * Every property read forwards to whatever config is installed *now*, so a
+ * plan swap is visible through this binding without any of its ~38 importers
+ * changing (ADR-0011). Capturing it — `const { title } = data` at module
+ * scope, or stashing the object in a module-level variable — reintroduces the
+ * staleness this indirection exists to remove.
+ */
+const data = createSwappableProxy('data', () => getConfig());
+export default data;

package/dist/esm/data/layer-viewbox.d.ts

@@ -0,0 +1,10 @@
+import { type FpRect } from '@expofp/schema';
+/**
+ * How far an authored layer viewbox is turned, in degrees clockwise in plan
+ * units (y down) — the direction of its top edge, p0 to p1. A viewbox without
+ * corners falls back to its `angle`; no viewbox, or neither, is unturned.
+ */
+export declare function viewboxRotation(viewbox: FpRect | null | undefined): number;
+/** {@link viewboxRotation} of a plan layer's authored viewbox, by layer name. */
+export declare function getLayerViewboxRotation(layerName: string): number;
+//# sourceMappingURL=layer-viewbox.d.ts.map

package/dist/esm/data/layer-viewbox.js

@@ -0,0 +1,20 @@
+import { getFpSvgJs } from './fp-payloads.js';
+/**
+ * How far an authored layer viewbox is turned, in degrees clockwise in plan
+ * units (y down) — the direction of its top edge, p0 to p1. A viewbox without
+ * corners falls back to its `angle`; no viewbox, or neither, is unturned.
+ */
+export function viewboxRotation(viewbox) {
+    if (!viewbox)
+        return 0;
+    const { p0, p1 } = viewbox;
+    if (p0 && p1 && (p0.x !== p1.x || p0.y !== p1.y)) {
+        return (Math.atan2(p1.y - p0.y, p1.x - p0.x) * 180) / Math.PI;
+    }
+    return Number.isFinite(viewbox.angle) ? viewbox.angle : 0;
+}
+/** {@link viewboxRotation} of a plan layer's authored viewbox, by layer name. */
+export function getLayerViewboxRotation(layerName) {
+    const layer = getFpSvgJs().__fpLayers?.find((entry) => entry.name === layerName);
+    return viewboxRotation(layer?.viewbox);
+}

package/dist/esm/data/svg.d.ts

@@ -0,0 +1,43 @@
+import { Box } from '@expofp/geometry';
+import { type FpPath } from '@expofp/schema';
+import { type GetFpPathMesh, type VenueContourExtraction } from '../components/Maplibre/utils/venue-contour';
+import { type Layer } from '../store/LayerStore.js';
+/** One floor rectangle authored as a `[data-floor]` element in the drawing. */
+interface SvgFloor {
+    name: string;
+    rect: Box;
+}
+/** The Fit-to-screen reference rectangle of the live event's drawing. */
+export declare function getSvgArea(): Box;
+/** Whether {@link getSvgArea} was authored rather than derived from the viewBox. */
+export declare function isSvgAreaExplicit(): boolean;
+/** The live event's floor rectangles; empty when the plan has no layers mode. */
+export declare function getFloors(): SvgFloor[];
+export declare function getTrianglesFromFpPaths(index: number, suffix: string): number[][][];
+export declare function gtePathByIndex(index: number, suffix?: string): FpPath;
+/**
+ * Exact layer lookup for geometry extraction; unlike the legacy helper it never
+ * falls back to base — a footprint read off the wrong layer's meshes would be
+ * silently wrong geometry rather than a missing one.
+ *
+ * Reads the resolved payload, never `window`. Generated payloads have not been
+ * script globals since `evalJsToJson` (`@expofp/utils`) began evaluating them
+ * against a sandbox, so a `window.__fpPaths<layer>` lookup here resolved to
+ * `undefined` for every path and cost every venue its authored footprint.
+ * `getFpPaths` throws before a config exists, which preloading and tests both
+ * reach, so the read is best-effort.
+ */
+export declare function getFpPathByIndex(index: number, suffix?: string): FpPath | undefined;
+export declare function getLayerSvg(layer?: Layer | string): SVGElement;
+/**
+ * Resolves a `data-index` on a plan layer's paths to its mesh. The index points
+ * into the mesh table of the document the layer's group lives in — a layer
+ * drawn into the base plan indexes the base table, not one of its own. The
+ * lookup is exact ({@link getFpPathByIndex}); only x and y are read downstream,
+ * so a mesh's optional z never matters.
+ */
+export declare function getLayerMeshLookup(layer: Layer | string): GetFpPathMesh;
+/** Production seam used by venue parsing to inspect a plan layer in plan-local coordinates. */
+export declare function extractVenueContourFromLayer(layer: Layer | string): VenueContourExtraction;
+export {};
+//# sourceMappingURL=svg.d.ts.map

package/dist/esm/data/svg.js

@@ -0,0 +1,210 @@
+import { Box } from '@expofp/geometry';
+import * as d3 from 'd3-selection';
+import { extractVenueContour, } from '../components/Maplibre/utils/venue-contour';
+import { STRING_META_DELIMITER } from '../constants.js';
+import { eventScopedCache, eventScopedValue } from '../tools/event-scoped-cache.js';
+import logger from '../tools/logger.js';
+import { extractMetaFromString } from '../utils/extractMetaFromString.js';
+import { getFpPaths, getFpSvg, getFpSvgJs } from './fp-payloads.js';
+// Parsed SVG documents by layer suffix ('' = the default drawing). Per event,
+// so a plan swap cannot hand event two the previous event's parsed drawing —
+// the crash at `config-bg.ts` traced back to exactly that (ADR-0011).
+const parsedSvgs = eventScopedCache();
+function parseSvg(text, suffix = '') {
+    const cached = parsedSvgs().get(suffix);
+    if (cached)
+        return cached;
+    const parser = new DOMParser();
+    const element = parser.parseFromString(text, 'image/svg+xml')
+        .documentElement;
+    if (element.firstChild?.tagName === 'parsererror')
+        logger.error('Parsed svg with error: ', element);
+    // prepare map of fill colors per class
+    const classFill = new Map();
+    d3.select(element)
+        .selectAll('style')
+        .each(function () {
+        const css = this.textContent ?? '';
+        const r = /\.([a-z0-9.]+)\s*{[^}]*fill\s*:\s*([^};]+);[^}]*}/gi;
+        let m;
+        while ((m = r.exec(css)) !== null) {
+            const cls = m[1], fill = m[2];
+            classFill.set(cls, fill);
+        }
+    });
+    // set fill attrs for elements having class attrs
+    d3.select(element)
+        .selectAll('*[class]')
+        .each(function () {
+        // Leave the element's own inline fill alone when its class carries none.
+        const fill = classFill.get(this.className.baseVal);
+        if (fill !== undefined)
+            this.style.fill = fill;
+    });
+    processElementsWithMeta(element);
+    parsedSvgs().set(suffix, element);
+    return element;
+}
+/**
+ * Parses the live event's default drawing and derives the view rectangles and
+ * floors from it. Runs once per plan, on the first read through any of the
+ * accessors below — never at module scope, which is what pinned the previous
+ * event's drawing across a swap.
+ */
+function buildSvgState() {
+    const svg = parseSvg(getFpSvg() ?? '');
+    const viewboxObj = getFpSvgJs().__viewbox;
+    const viewboxRect = d3.select(svg).select('rect#VIEWBOX').node();
+    const viewBoxBaseVal = svg.viewBox.baseVal;
+    const viewBox = new Box(viewBoxBaseVal.x, viewBoxBaseVal.y, viewBoxBaseVal.width, viewBoxBaseVal.height);
+    let area;
+    let areaExplicit = false;
+    if (viewboxObj) {
+        area = new Box(viewboxObj.x, viewboxObj.y, viewboxObj.width, viewboxObj.height);
+        areaExplicit = true;
+        viewboxRect?.remove();
+    }
+    else if (viewboxRect) {
+        area = Box.fromSvg(viewboxRect);
+        areaExplicit = true;
+        viewboxRect.remove();
+    }
+    else {
+        // Inflate the viewBox by 10% about its center (each side +5%), matching the
+        // legacy `withPadding(-w*0.05, -h*0.05)` which grew the rect by the same factor.
+        area = viewBox.scale(1.1);
+    }
+    d3.select(svg).attr('width', viewBox.size.width);
+    d3.select(svg).attr('height', viewBox.size.height);
+    logger.log('svgArea', area, 'svgViewBox', viewBox);
+    const floors = getFpSvgJs().__fpLayersMode
+        ? d3
+            .select(svg)
+            .selectAll('[data-floor]')
+            .nodes()
+            .map((f) => {
+            f.remove();
+            return {
+                name: f.dataset.floor ?? '',
+                rect: Box.fromSvg(f),
+            };
+        })
+            .sort()
+        : [];
+    return { area, areaExplicit, floors };
+}
+const svgState = eventScopedValue(buildSvgState);
+/** The Fit-to-screen reference rectangle of the live event's drawing. */
+export function getSvgArea() {
+    return svgState().area;
+}
+/** Whether {@link getSvgArea} was authored rather than derived from the viewBox. */
+export function isSvgAreaExplicit() {
+    return svgState().areaExplicit;
+}
+/** The live event's floor rectangles; empty when the plan has no layers mode. */
+export function getFloors() {
+    return svgState().floors;
+}
+export function getTrianglesFromFpPaths(index, suffix) {
+    const mesh = gtePathByIndex(index, suffix);
+    // The resolved payload is frozen (resolve() deep-freezes documents), so
+    // normalize into `[x, abs(y)]` copies instead of patching the mesh in place
+    // (abs: a bug in svgMesh3d when normalize: false ? — TODO: drop when settled).
+    const positions = mesh.positions.map((p) => [p[0], Math.abs(p[1])]);
+    const pathTriangles = [];
+    for (const c of mesh.cells) {
+        pathTriangles.push([positions[c[0]], positions[c[1]], positions[c[2]]]);
+    }
+    return pathTriangles;
+}
+export function gtePathByIndex(index, suffix = '') {
+    // a layer's paths, else the default drawing's (the old window-global lookup
+    // fell back to whichever layer file loaded last — an accident of script
+    // side effects, not behavior worth keeping)
+    const paths = getFpPaths(suffix) ?? getFpPaths();
+    if (!paths)
+        throw new Error(`No meshes for layer "${suffix}"`);
+    return paths[index];
+}
+/**
+ * Exact layer lookup for geometry extraction; unlike the legacy helper it never
+ * falls back to base — a footprint read off the wrong layer's meshes would be
+ * silently wrong geometry rather than a missing one.
+ *
+ * Reads the resolved payload, never `window`. Generated payloads have not been
+ * script globals since `evalJsToJson` (`@expofp/utils`) began evaluating them
+ * against a sandbox, so a `window.__fpPaths<layer>` lookup here resolved to
+ * `undefined` for every path and cost every venue its authored footprint.
+ * `getFpPaths` throws before a config exists, which preloading and tests both
+ * reach, so the read is best-effort.
+ */
+export function getFpPathByIndex(index, suffix = '') {
+    try {
+        return getFpPaths(suffix)?.[index];
+    }
+    catch {
+        return undefined;
+    }
+}
+export function getLayerSvg(layer = '') {
+    // Building the derived state parses and prepares the default drawing, which
+    // every lookup below falls back to — and it has to have happened before any
+    // caller can hold that document, exactly as the old module-scope parse did.
+    svgState();
+    // a sub-layer is drawn on its root's document, not its own
+    const name = typeof layer === 'string' ? layer : (layer.rootParent?.name ?? layer.name);
+    const cached = parsedSvgs().get(name);
+    if (cached)
+        return cached;
+    const text = getFpSvg(name);
+    // the default drawing is the fallback for a layer that carries none
+    return text ? parseSvg(text, name) : parsedSvgs().get('');
+}
+/**
+ * Resolves a `data-index` on a plan layer's paths to its mesh. The index points
+ * into the mesh table of the document the layer's group lives in — a layer
+ * drawn into the base plan indexes the base table, not one of its own. The
+ * lookup is exact ({@link getFpPathByIndex}); only x and y are read downstream,
+ * so a mesh's optional z never matters.
+ */
+export function getLayerMeshLookup(layer) {
+    const name = typeof layer === 'string' ? layer : (layer.rootParent?.name ?? layer.name);
+    const embedded = getLayerSvg(layer) === getLayerSvg('');
+    return (index) => getFpPathByIndex(index, embedded ? '' : name);
+}
+/** Production seam used by venue parsing to inspect a plan layer in plan-local coordinates. */
+export function extractVenueContourFromLayer(layer) {
+    const name = typeof layer === 'string' ? layer : (layer.rootParent?.name ?? layer.name);
+    const layerSvg = getLayerSvg(layer);
+    const embedded = layerSvg === getLayerSvg('');
+    const layerRoot = layerSvg.querySelector(`[data-layer="${name}"]`);
+    // A standalone layer payload is its own document, so its root is the layer.
+    // The base plan document is not: scanning it would return the bounding box of
+    // every booth in the plan, so leave the contour unresolved instead and let
+    // §6 fall through to the next scene layer or the level-rect hull.
+    const root = layerRoot ?? (embedded ? null : layerSvg);
+    // Nothing was inspected, so no shape can be named: the fallthrough is
+    // reported, but there is no artwork to tell the author to redraw.
+    if (!root)
+        return { ring: null, unusableElementKinds: [] };
+    return extractVenueContour(root, getLayerMeshLookup(layer));
+}
+function processElementsWithMeta(element) {
+    d3.select(element)
+        .selectAll('[id], [data-name]')
+        .each(function () {
+        let combinedMeta = {};
+        const dataName = this.getAttribute('data-name');
+        if (dataName && dataName.includes(STRING_META_DELIMITER)) {
+            const { meta: nameMeta } = extractMetaFromString(dataName);
+            combinedMeta = { ...combinedMeta, ...nameMeta };
+        }
+        const id = this.getAttribute('id');
+        if (id && id.includes(STRING_META_DELIMITER)) {
+            const { meta: idMeta } = extractMetaFromString(id);
+            combinedMeta = { ...combinedMeta, ...idMeta };
+        }
+        this.setAttribute('data-meta', JSON.stringify(combinedMeta));
+    });
+}