@expofp/floorplan 0.0.0-experimental.2632d13 → 0.0.0-experimental.6dabc65

package/dist/esm/store/RouteStore.js

@@ -9,6 +9,7 @@ import { getFpGeo } from '../data/fpGeo.js';
 import { getLayerSvg, getSvgArea } from '../data/svg.js';
 import { GaEventActions, sendEventToGa } from '../tools/gtag';
 import logger from '../tools/logger';
+import settings from '../tools/settings';
 import { areLayersEnabled } from '../utils/areLayersEnabled';
 import { calcSpeed } from '../utils/calcSpeed';
 import { calcTravelTime } from '../utils/calcTravelTime';
@@ -18,6 +19,7 @@ import store, { layersStore, uiState } from '.';
 import { BoothBase } from './BoothStore';
 import { LayersMode } from './LayerStore';
 import { revealLayer } from './reveal-layer.js';
+import { venueLevelForFix } from './VenueStore.js';
 /** A coordinate as the SDK may deliver it — `1.5`, or `"1,5"` from a comma locale. */
 function replaceCommasWithDot(value) {
     if (typeof value === 'string') {
@@ -107,9 +109,14 @@ export default class RouteStore {
                 return;
             if (destinationReady) {
                 void destinationReady.then(() => {
-                    if (selectRouteRequest === this.selectRouteRequest) {
-                        this.rootStore.moveToList(list, true);
-                    }
+                    if (selectRouteRequest !== this.selectRouteRequest)
+                        return;
+                    // A route the engine has already drawn framed itself as it did (`onRouteUpdate`), and
+                    // this focus, held back for the destination's level, would land after that fit and
+                    // pull the camera onto the listed booths — from the blue dot, the destination alone.
+                    if (this.routedRoute === route && this.routeLines.length)
+                        return;
+                    this.rootStore.moveToList(list, true);
                 });
             }
             else {
@@ -172,6 +179,23 @@ export default class RouteStore {
             ?.filter((name, i, self) => self.indexOf(name) === i);
         return routeSteps(layers ?? [], this.campusLayersBox.get(), (name) => Boolean(store.layerStore.findLayer(name))).map((name, i) => ({ id: i + 1, layer: store.layerStore.findLayer(name) }));
     }
+    /**
+     * The floor a plan point stands on — a position fix, or a coordinate route endpoint. Floors
+     * belong to venues, so on a venue-model plan the outline the point lies in decides: outdoors it
+     * stands on none, whatever floor it reports; inside a venue it keeps the reported floor only when
+     * that floor is one of the venue's own levels, and otherwise takes the venue's
+     * (`venueLevelForFix`). Another hall's floor would scope the point to that hall — read as off a
+     * route right under it, and start a route "from here" at that hall's nearest walkway. Off a
+     * venue model the reported floor stands as is.
+     */
+    pointLayer(point, z) {
+        const reported = this.rootStore.layerStore.findLayer(z);
+        const venueStore = this.rootStore.venueStore;
+        if (!venueStore?.hasVenueModel)
+            return reported;
+        const venue = venueStore.venueAt(point);
+        return venue ? venueLevelForFix(venue, reported?.name).layer : null;
+    }
     /**
      * Used only by the SDK `getBooth(RouteWaypoint)` path for coord-form
      * waypoints (`floorplan.ready.tsx`). Internal callers prefer
@@ -181,7 +205,6 @@ export default class RouteStore {
     getNearestBooth(position) {
         if (!position)
             return null;
-        const layerExists = this.rootStore.layerStore.findLayer(position.z);
         const gpsConfig = getFpGeo()?.properties.config;
         const isGpsFix = Boolean(position.lat && position.lng);
         const localPoint = gpsConfig && isGpsFix ? convertGpsToLocal(position, gpsConfig) : position;
@@ -190,15 +213,17 @@ export default class RouteStore {
         if (!localPoint || !isValidPointCoords(localPoint.x) || !isValidPointCoords(localPoint.y)) {
             return null;
         }
+        const layer = this.pointLayer(localPoint, position.z);
+        // Off a venue model an empty `z` can still match a layer by name, and such a floorless fix keeps
+        // every visible booth in play, as before; on one, the floor `pointLayer` decided is the answer.
+        const floorless = !this.rootStore.venueStore?.hasVenueModel && typeof position.z !== 'number' && !position.z;
         return (this.rootStore.boothStore.booths
             .filter((b) => {
-            if (layersStore.mode === LayersMode.Default || !layerExists) {
+            if (this.rootStore.layerStore.mode === LayersMode.Default || !layer) {
                 return b.visible && b.rect;
             }
             else {
-                return (b.rect &&
-                    ((typeof position.z !== 'number' && !position.z && b.visible) ||
-                        layerExists.name === b.layer?.name));
+                return b.rect && ((floorless && b.visible) || layer.name === b.layer?.name);
             }
         })
             .sort((b1, b2) => pointDistance(localPoint, b1.rect.center) - pointDistance(localPoint, b2.rect.center))[0] || null);
@@ -276,7 +301,9 @@ export default class RouteStore {
             // name merely holds the number (13 → Hall13).
             const floors = this.rootStore.layerStore.layers.filter((layer) => !layer.rootParent && !layer.frozen);
             const noFloorAtIndex = typeof point.z === 'number' && !floors[point.z];
-            if ((data.ignoreUnknownFloorIndex === true && noFloorAtIndex) || !areLayersEnabled()) {
+            if (settings.EXPO === 'eurotier2026' ||
+                (data.ignoreUnknownFloorIndex === true && noFloorAtIndex) ||
+                !areLayersEnabled()) {
                 point.z = undefined;
             }
         }
@@ -292,13 +319,13 @@ export default class RouteStore {
             this.currentPosition = null;
             return;
         }
-        // Floors belong to venues: a fix outside every venue outline stands on none, whatever floor it
-        // reports and whichever floor the route is on. A floor it is not on would scope it to that
-        // hall — read as off a route that is right under it, and start a route from inside the hall.
-        const venueStore = this.rootStore.venueStore;
-        const outdoors = !!venueStore?.hasVenueModel && !venueStore.venueAt(position);
-        const layer = outdoors ? null : store.layerStore.findLayer(point.z);
-        const newPosition = new CurrentPosition(position.x, position.y, outdoors ? undefined : layer?.name || this.currentRouteLayer?.name, calculateRelativeBearing(position), point.lat, point.lng);
+        const layer = this.pointLayer(position, point.z);
+        // Off a venue model, a fix without a floor takes the route's; on one, `pointLayer` has
+        // already decided — no floor outdoors, the venue's own inside an outline.
+        const routeLayerFallback = this.rootStore.venueStore?.hasVenueModel
+            ? undefined
+            : this.currentRouteLayer?.name;
+        const newPosition = new CurrentPosition(position.x, position.y, layer?.name || routeLayerFallback, calculateRelativeBearing(position), point.lat, point.lng);
         let isPositionAndRouteOnTheSameLayer = !this.routeLines?.length;
         if (layer && this.routeLines?.length) {
             isPositionAndRouteOnTheSameLayer = !!this.routeLines.find((line) => line.p0.layer === layer.name || line.p1.layer === layer.name);

package/dist/esm/store/VenueStore.d.ts

@@ -94,6 +94,13 @@ export declare class Venue {
     /** Full floor detail currently visible (R6); unevaluated counts as visible. */
     get detailVisible(): boolean;
 }
+/**
+ * The level of `venue` that a position fix inside it stands on: the reported floor when it is one
+ * of the venue's own levels, otherwise the level the venue shows. The outline a fix lies in names
+ * its venue beyond doubt; the floor it reports can be wrong — a positioning system may carry an
+ * indoor floor over onto later GPS fixes, or number the floors its own way.
+ */
+export declare function venueLevelForFix(venue: Pick<Venue, 'levels' | 'activeLevel'>, reportedLayerName: string | undefined): VenueLevel;
 /**
  * Owns the venue model of a multi-venue plan: the venue list, viewport focus,
  * and each venue's active level. Levels stay owned by LayerStore; a venue

package/dist/esm/store/VenueStore.js

@@ -89,6 +89,15 @@ export class Venue {
         return this._presentationState.get()?.detailVisible ?? true;
     }
 }
+/**
+ * The level of `venue` that a position fix inside it stands on: the reported floor when it is one
+ * of the venue's own levels, otherwise the level the venue shows. The outline a fix lies in names
+ * its venue beyond doubt; the floor it reports can be wrong — a positioning system may carry an
+ * indoor floor over onto later GPS fixes, or number the floors its own way.
+ */
+export function venueLevelForFix(venue, reportedLayerName) {
+    return venue.levels.find((level) => level.layer.name === reportedLayerName) ?? venue.activeLevel;
+}
 /**
  * Owns the venue model of a multi-venue plan: the venue list, viewport focus,
  * and each venue's active level. Levels stay owned by LayerStore; a venue

package/dist/esm/tools/settings.js

@@ -64,7 +64,7 @@ class Settings extends FpSettings {
  */
 function buildSettings() {
     let settings = new Settings();
-    if (settings.EXPO.startsWith('sxsw2024')) {
+    if (settings.EXPO === 'sxsw2024') {
         settings.colors.booths.selected = '#FF6400';
         settings.colors.booths.seectedLight = '#808080';
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expofp/floorplan",
-  "version": "0.0.0-experimental.2632d13",
+  "version": "0.0.0-experimental.6dabc65",
   "repository": {
     "type": "git",
     "url": "https://github.com/expofp/efp-app.git",
@@ -69,15 +69,15 @@
     "tslib": "^2.3.0",
     "uuid": "^9.0.1",
     "zod": "4.4.3",
-    "@expofp/config": "0.0.0-experimental.2632d13",
-    "@expofp/debug": "0.0.0-experimental.2632d13",
-    "@expofp/geometry": "0.0.0-experimental.2632d13",
-    "@expofp/renderer": "0.0.0-experimental.2632d13",
-    "@expofp/resolve": "0.0.0-experimental.2632d13",
-    "@expofp/schema": "0.0.0-experimental.2632d13",
-    "@expofp/ui": "0.0.0-experimental.2632d13",
-    "@expofp/utils": "0.0.0-experimental.2632d13",
-    "@expofp/wayfinding": "0.0.0-experimental.2632d13"
+    "@expofp/config": "0.0.0-experimental.6dabc65",
+    "@expofp/debug": "0.0.0-experimental.6dabc65",
+    "@expofp/geometry": "0.0.0-experimental.6dabc65",
+    "@expofp/renderer": "0.0.0-experimental.6dabc65",
+    "@expofp/resolve": "0.0.0-experimental.6dabc65",
+    "@expofp/schema": "0.0.0-experimental.6dabc65",
+    "@expofp/ui": "0.0.0-experimental.6dabc65",
+    "@expofp/utils": "0.0.0-experimental.6dabc65",
+    "@expofp/wayfinding": "0.0.0-experimental.6dabc65"
   },
   "devDependencies": {
     "@babel/plugin-proposal-decorators": "^8.0.2",

package/dist/browser/venues-Yq0wU18A.js

@@ -1,447 +0,0 @@
-(function() {
-	try {
-		var e = typeof window < "u" ? window : typeof global < "u" ? global : typeof globalThis < "u" ? globalThis : typeof self < "u" ? self : {};
-		e.SENTRY_RELEASE = { id: "3.45.6" };
-		var t = new e.Error().stack;
-		t && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[t] = "5f4c3e09-f59c-417b-b628-a47d62512eb3", e._sentryDebugIdIdentifier = "sentry-dbid-5f4c3e09-f59c-417b-b628-a47d62512eb3");
-	} catch {}
-})();
-import { _n as e, gn as t, mn as n, un as r } from "./LayerStore-DCwl80sb.js";
-//#region src/data/venues.ts
-var i = /^[a-z0-9_-]+$/, a = ["scene", "marker"], o = 11, s = 10;
-function c(e, t) {
-	return e * s >= t * o;
-}
-function l(e) {
-	return e === 60 ? 66 : Math.ceil(e * o / s);
-}
-var u = /* @__PURE__ */ new Set([
-	"id",
-	"name",
-	"order",
-	"levels",
-	"contour",
-	"markerPoint",
-	"detailMinSizePx",
-	"markerMaxSizePx",
-	"layers",
-	"entrances",
-	"campusViewbox"
-]), d = /* @__PURE__ */ new Set([
-	"layer",
-	"ordinal",
-	"name",
-	"initial"
-]), f = /* @__PURE__ */ new Set([
-	"layer",
-	"point",
-	"name"
-]), p = /* @__PURE__ */ new Set([
-	"layer",
-	"render",
-	"replacesDefault",
-	"suppressesLabel",
-	"minSizePx",
-	"maxSizePx"
-]), m = (e, t) => e < t ? -1 : +(e > t), h = (e) => typeof e == "object" && !!e && !Array.isArray(e), g = (e) => typeof e == "number" && Number.isFinite(e), _ = (e) => typeof e == "string" && e.length > 0, v = (e) => h(e) && g(e.x) && g(e.y), y = (e) => h(e) && g(e.x) && g(e.y) && g(e.width) && g(e.height) && e.width > 0 && e.height > 0;
-function b(e) {
-	try {
-		let t = JSON.stringify(e);
-		return t === void 0 ? String(e) : t;
-	} catch {
-		return String(e);
-	}
-}
-function x(e) {
-	for (let t of e) try {
-		console.warn("parseVenues:", `${t.code} (${t.effect}) ${t.path || "(root)"}: ${t.message}; ${t.consequence}`);
-	} catch {}
-}
-function S(e, t, n, r = null) {
-	return x(t), {
-		venues: e,
-		diagnostics: t,
-		quarantinedLayerNames: n,
-		campusViewbox: r
-	};
-}
-function C(e, t, n, r) {
-	let i = (e, t, n) => (t.x - e.x) * (n.y - e.y) - (t.y - e.y) * (n.x - e.x), a = i(n, r, e), o = i(n, r, t), s = i(e, t, n), c = i(e, t, r);
-	if ((a > 0 && o < 0 || a < 0 && o > 0) && (s > 0 && c < 0 || s < 0 && c > 0)) return !0;
-	let l = (e, t, n) => Math.min(e.x, t.x) <= n.x && n.x <= Math.max(e.x, t.x) && Math.min(e.y, t.y) <= n.y && n.y <= Math.max(e.y, t.y);
-	return a === 0 && l(n, r, e) || o === 0 && l(n, r, t) || s === 0 && l(e, t, n) || c === 0 && l(e, t, r);
-}
-function w(e) {
-	if (!Array.isArray(e)) return { issue: "is not an array" };
-	if (e.length < 3) return { issue: `has ${e.length} point(s); a ring needs at least 3` };
-	if (!e.every(v)) return { issue: "contains a non-finite or malformed point" };
-	let t = e.map((e) => ({
-		x: e.x,
-		y: e.y
-	})), n = t[0], i = t[t.length - 1];
-	if (n.x === i.x && n.y === i.y && t.pop(), t.length < 3) return { issue: `has ${t.length} point(s); a ring needs at least 3` };
-	let { width: a, height: o } = r.fromPoints(t).size;
-	if (a === 0 || o === 0) return { issue: "is degenerate (zero width or height)" };
-	for (let e = 0; e < t.length; e++) {
-		let n = t[e], r = t[(e + 1) % t.length];
-		for (let i = e + 1; i < t.length; i++) if (!(i === e || (i + 1) % t.length === e || (e + 1) % t.length === i) && C(n, r, t[i], t[(i + 1) % t.length])) return { issue: "is self-intersecting; v1 accepts one simple ring only (no holes, no multi-part)" };
-	}
-	let s = 0;
-	for (let e = 0; e < t.length; e++) {
-		let n = t[e], r = t[(e + 1) % t.length];
-		s += n.x * r.y - r.x * n.y;
-	}
-	return s === 0 ? { issue: "is degenerate (zero area)" } : { ring: t };
-}
-function T(e, r) {
-	let i = [];
-	for (let t of e) {
-		var a;
-		if (!t.surviving) continue;
-		let e = r.get(t.value.layer), o = (a = e == null ? void 0 : e.rect) == null ? e == null ? void 0 : e.viewbox : a;
-		!o || o.area <= 0 || i.push(...n(o).map((e) => ({
-			x: e.x,
-			y: e.y
-		})));
-	}
-	return t(i);
-}
-function E(e, t, n = []) {
-	try {
-		return D(e, t, n);
-	} catch {
-		return S([], [{
-			code: "venues-payload-invalid",
-			path: "venues",
-			message: "could not be parsed",
-			consequence: "plan loads as single-venue",
-			effect: "dropped"
-		}], []);
-	}
-}
-function D(t, n, o) {
-	let s = [], x = (e) => (t, n, r, i) => s.push({
-		code: t,
-		path: n,
-		message: r,
-		consequence: i,
-		effect: e
-	}), C = x("dropped"), E = x("fallback"), D = x("clamped"), O = x("advisory"), k = (e, t, n) => {
-		for (let r of Object.keys(t)) n.has(r) || O("unknown-key", `${e}.${r}`, "is not a contract field", "ignored by the SDK");
-	}, A = (e) => {
-		let t = s.length;
-		try {
-			return e();
-		} finally {
-			s.length = t;
-		}
-	}, j = /* @__PURE__ */ new Set();
-	for (let e of o) for (let t of e) j.add(t.layer);
-	if (t == null) return S([], s, []);
-	if (!h(t)) return C("venues-payload-invalid", "", "payload is not an object", "nothing to parse"), S([], s, []);
-	let M = t.venues;
-	if (M === void 0) return S([], s, []);
-	if (t.venuesVersion !== void 0 && t.venuesVersion !== 1) return C("venues-version-unsupported", "venuesVersion", `payload version ${b(t.venuesVersion)} is unsupported; SDK supports version 1`, "whole venues array ignored; plan loads as single-venue"), S([], s, []);
-	if (!Array.isArray(M)) return C("venues-payload-invalid", "venues", "is not an array", "plan loads as single-venue"), S([], s, []);
-	let N = /* @__PURE__ */ new Map(), P = /* @__PURE__ */ new Map(), F = /* @__PURE__ */ new Map();
-	M.forEach((e, t) => {
-		if (!h(e) || !_(e.name)) return;
-		let n = `venues[${t}]`, r = e.name.toLowerCase(), i = P.get(r);
-		i ? F.set(n, i) : P.set(r, n);
-	});
-	let I = M.map((e, t) => {
-		var r, o;
-		let s = `venues[${t}]`;
-		if (!h(e)) return C("venue-identity-invalid", s, "is not an object", "venue dropped"), {
-			at: s,
-			label: s,
-			claimable: !1,
-			order: t,
-			levels: [],
-			aux: [],
-			entrances: [],
-			expectedSceneLayers: [],
-			referencedLayers: []
-		};
-		k(s, e, u);
-		let m = !0, y = e.id;
-		_(y) ? (i.test(y) || (C("venue-identity-invalid", `${s}.id`, `"${y}" must match ${i} (lowercase alphanumerics, hyphen, underscore)`, "id is used as a MapLibre feature id, a style-image id and a ?camera[venue]= deep-link value"), m = !1), N.has(y) ? (C("venue-id-duplicate", `${s}.id`, `"${y}" duplicates ${N.get(y)}`, "this venue dropped"), m = !1) : N.set(y, s)) : (C("venue-identity-invalid", `${s}.id`, "is missing or not a non-empty string", "venue dropped"), m = !1);
-		let x = _(y) ? `"${y}"` : s, S = e.name;
-		_(S) ? F.has(s) && O("venue-name-duplicate", `${s}.name`, `"${S}" duplicates the name of ${F.get(s)} (case-insensitive)`, "nothing dropped — two identical rows in the venue switch, ambiguous search results") : (C("venue-identity-invalid", `${s}.name`, "is missing or not a non-empty string", "venue dropped"), m = !1);
-		let T = t;
-		Number.isInteger(e.order) ? T = e.order : E("venue-order-invalid", `${s}.order`, e.order === void 0 ? "is missing" : "is not an integer", "falls back to array position; order is contractually required (§9)");
-		let A = [], M = (e, t = !1) => {
-			_(e) && !e.startsWith("WF") && t && !A.includes(e) && A.push(e);
-		}, P = [];
-		if (!Array.isArray(e.levels) || e.levels.length === 0) C("venue-levels-missing", `${s}.levels`, "is missing or empty", "venue dropped"), m = !1;
-		else {
-			e.levels.forEach((e, t) => {
-				let r = `${s}.levels[${t}]`;
-				if (!h(e)) {
-					C("level-entry-invalid", r, "is not an object", "level dropped");
-					return;
-				}
-				k(r, e, d), M(e.layer, n.has(e.layer));
-				let i = !0;
-				_(e.layer) ? (n.has(e.layer) || (C("level-layer-unknown", `${r}.layer`, `"${e.layer}" does not exist in the plan`, `level dropped; venue ${x} loses this floor (check for a rename or typo)`), i = !1), e.layer.startsWith("WF") && (C("level-layer-wayfinding", `${r}.layer`, `"${e.layer}" is a wayfinding layer`, "WF* layers are excluded before the venue model sees them — level dropped"), i = !1)) : (C("level-layer-invalid", `${r}.layer`, "is missing or not a non-empty string", "level dropped"), i = !1), Number.isInteger(e.ordinal) || (C("level-ordinal-invalid", `${r}.ordinal`, "is missing or not an integer", "level dropped; ordinal is required (0 = ground, -1 = basement)"), i = !1), e.name !== void 0 && !_(e.name) && E("level-field-invalid", `${r}.name`, "is not a non-empty string", "falls back to the layer's description"), e.initial !== void 0 && typeof e.initial != "boolean" && E("level-field-invalid", `${r}.initial`, "is not a boolean", "ignored"), P.push({
-					value: {
-						layer: _(e.layer) ? e.layer : "",
-						ordinal: Number.isInteger(e.ordinal) ? e.ordinal : 0,
-						name: _(e.name) ? e.name : void 0,
-						initial: typeof e.initial == "boolean" ? e.initial : void 0
-					},
-					at: r,
-					ok: i,
-					surviving: !1
-				});
-			});
-			let t = /* @__PURE__ */ new Map();
-			for (let e of P) {
-				if (!e.ok) continue;
-				let n = e.value.ordinal, r = t.get(n);
-				r ? (C("level-ordinal-duplicate", `${e.at}.ordinal`, `${n} duplicates ${r}`, "level dropped; ordinals are unique within a venue"), e.ok = !1) : t.set(n, e.at);
-			}
-		}
-		let I;
-		if (e.contour !== void 0) {
-			let t = w(e.contour);
-			t.issue ? E("contour-invalid", `${s}.contour`, t.issue, "falls back to the scene layer's geometry, then to the hull of level rects") : I = t.ring;
-		}
-		let L;
-		e.markerPoint !== void 0 && (v(e.markerPoint) ? L = {
-			x: e.markerPoint.x,
-			y: e.markerPoint.y
-		} : E("venue-marker-point-invalid", `${s}.markerPoint`, "is not a finite {x, y} point", "falls back to the contour centroid"));
-		let R;
-		e.detailMinSizePx !== void 0 && (!g(e.detailMinSizePx) || e.detailMinSizePx <= 0 ? E("detail-min-size-invalid", `${s}.detailMinSizePx`, "is not a positive finite number", "default 240 used") : R = e.detailMinSizePx);
-		let z;
-		if (e.markerMaxSizePx !== void 0) {
-			let t = R === void 0 ? 240 : Math.max(66, R);
-			!g(e.markerMaxSizePx) || e.markerMaxSizePx <= 0 ? E("marker-max-size-invalid", `${s}.markerMaxSizePx`, "is not a positive finite number", "default 60 used") : e.markerMaxSizePx >= t ? E("marker-max-size-inverted", `${s}.markerMaxSizePx`, `${e.markerMaxSizePx} is at or above the venue's resolved detailMinSizePx of ${t}`, "default 60 used, then the detail-edge clamp applies") : z = e.markerMaxSizePx;
-		}
-		let B = (r = z) == null ? 60 : r;
-		if (R !== void 0 && !c(R, B)) {
-			let e = l(B);
-			D("detail-min-size-clamped", `${s}.detailMinSizePx`, `${R} is below the ${e}px marker/scene sticky enter edge`, `clamped to ${e}`), R = e;
-		}
-		let V = (o = R) == null ? 240 : o, H = [], U = [];
-		e.layers !== void 0 && (Array.isArray(e.layers) ? e.layers.forEach((e, t) => {
-			let r = `${s}.layers[${t}]`;
-			if (!h(e)) {
-				C("aux-entry-invalid", r, "is not an object", "entry dropped");
-				return;
-			}
-			k(r, e, p), _(e.layer) && e.render === "scene" && (e.replacesDefault === void 0 || e.replacesDefault === !0) && U.push(e.layer);
-			let i = _(e.layer) && (n.has(e.layer) || j.has(e.layer));
-			M(e.layer, i);
-			let o = !0;
-			_(e.layer) ? (i || (C("aux-layer-unknown", `${r}.layer`, `"${e.layer}" does not exist in the plan`, "entry dropped; venue falls back to the procedural appearance"), o = !1), e.layer.startsWith("WF") && (C("aux-layer-wayfinding", `${r}.layer`, `"${e.layer}" is a wayfinding layer`, "WF* layers are excluded before the venue model sees them — entry dropped"), o = !1)) : (C("aux-layer-invalid", `${r}.layer`, "is missing or not a non-empty string", "entry dropped"), o = !1);
-			let c = a.includes(e.render);
-			c || (C("aux-entry-invalid", `${r}.render`, `is ${b(e.render)}, expected "scene" or "marker"`, "entry dropped"), o = !1), e.replacesDefault !== void 0 && typeof e.replacesDefault != "boolean" && (C("aux-entry-invalid", `${r}.replacesDefault`, "is not a boolean", "entry dropped"), o = !1), e.suppressesLabel !== void 0 && typeof e.suppressesLabel != "boolean" && (C("aux-entry-invalid", `${r}.suppressesLabel`, "is not a boolean", "entry dropped"), o = !1), e.minSizePx !== void 0 && (!g(e.minSizePx) || e.minSizePx < 0) && (C("aux-entry-invalid", `${r}.minSizePx`, "is not a non-negative finite number", "entry dropped"), o = !1), e.maxSizePx !== void 0 && e.maxSizePx !== "detail" && (!g(e.maxSizePx) || e.maxSizePx < 0) && (C("aux-entry-invalid", `${r}.maxSizePx`, "is not a non-negative finite number or the literal \"detail\"", "entry dropped"), o = !1), g(e.minSizePx) && g(e.maxSizePx) && e.minSizePx >= 0 && e.maxSizePx >= 0 && e.minSizePx > e.maxSizePx && (C("aux-range-inverted", r, `minSizePx ${e.minSizePx} exceeds maxSizePx ${e.maxSizePx}`, "entry dropped"), o = !1);
-			let l = c ? e.render : "scene", u = g(e.minSizePx) && e.minSizePx >= 0 ? e.minSizePx : l === "marker" ? 0 : B, d = e.maxSizePx !== void 0 && (e.maxSizePx === "detail" || g(e.maxSizePx)) ? e.maxSizePx : l === "scene" ? "detail" : B;
-			c && (d === "detail" ? u >= V : u > d) && (C("aux-range-never-visible", r, `resolved range ${u}..${d} can never render`, "entry dropped; the procedural fallback for this render mode is restored"), o = !1), c && l === "scene" && g(e.maxSizePx) && O("aux-max-size-numeric", `${r}.maxSizePx`, `is the hard edge ${e.maxSizePx} rather than "detail"`, "a static edge cannot follow the ±10% detail hysteresis — expect flicker and brief overlap with the floor plan"), H.push({
-				value: {
-					layer: _(e.layer) ? e.layer : "",
-					render: l,
-					replacesDefault: typeof e.replacesDefault == "boolean" ? e.replacesDefault : void 0,
-					suppressesLabel: typeof e.suppressesLabel == "boolean" ? e.suppressesLabel : void 0,
-					minSizePx: g(e.minSizePx) ? e.minSizePx : void 0,
-					maxSizePx: e.maxSizePx === "detail" || g(e.maxSizePx) ? e.maxSizePx : void 0
-				},
-				at: r,
-				ok: o,
-				surviving: !1
-			});
-		}) : E("aux-layers-invalid", `${s}.layers`, "is not an array", "ignored; procedural appearance used"));
-		let W = new Set((Array.isArray(e.levels) ? e.levels : []).filter(h).map((e) => e.layer).filter(_)), G = [];
-		return e.entrances !== void 0 && (Array.isArray(e.entrances) ? e.entrances.forEach((e, t) => {
-			let n = `${s}.entrances[${t}]`;
-			if (!h(e)) {
-				C("entrance-entry-invalid", n, "is not an object", "entrance dropped");
-				return;
-			}
-			k(n, e, f);
-			let r = !0;
-			_(e.layer) ? W.has(e.layer) || (C("entrance-layer-foreign", `${n}.layer`, `"${e.layer}" is not a level of venue ${x}`, "entrance dropped; an entrance stands on one of its own venue’s levels"), r = !1) : (C("entrance-layer-invalid", `${n}.layer`, "is missing or not a non-empty string", "entrance dropped"), r = !1), v(e.point) || (C("entrance-entry-invalid", `${n}.point`, "is missing or not a finite {x, y} point", "entrance dropped; an entrance is a point before it is anything else"), r = !1), e.name !== void 0 && !_(e.name) && E("entrance-field-invalid", `${n}.name`, "is not a non-empty string", "falls back to the venue’s own name"), !(!r || !_(e.layer) || !v(e.point)) && G.push({
-				value: {
-					layer: e.layer,
-					point: {
-						x: e.point.x,
-						y: e.point.y
-					},
-					name: _(e.name) ? e.name : void 0
-				},
-				at: n
-			});
-		}) : E("entrances-invalid", `${s}.entrances`, "is not an array", "ignored; the venue keeps marker-point targeting")), {
-			at: s,
-			id: _(y) ? y : void 0,
-			name: _(S) ? S : void 0,
-			label: x,
-			claimable: m,
-			order: T,
-			levels: P,
-			aux: H,
-			entrances: G,
-			expectedSceneLayers: U,
-			contour: I,
-			markerPoint: L,
-			detailMinSizePx: R,
-			markerMaxSizePx: z,
-			referencedLayers: A,
-			campusViewbox: e.campusViewbox
-		};
-	}), L = /* @__PURE__ */ new Set(), R = [...I].sort((e, t) => {
-		var n, r;
-		return e.order - t.order || m((n = e.id) == null ? "" : n, (r = t.id) == null ? "" : r);
-	}), z = null, B;
-	for (let e of R) {
-		if (e.campusViewbox === void 0) continue;
-		let t = `${e.at}.campusViewbox`;
-		if (B) {
-			C("campus-viewbox-duplicate", t, `${B.at} already carries the campus viewbox`, "this venue's value is ignored; the first carrier by order wins");
-			continue;
-		}
-		B = e;
-		let n = e.campusViewbox;
-		y(n) ? z = new r(n.x, n.y, n.width, n.height) : E("campus-viewbox-invalid", t, "is not an {x, y, width, height} of finite numbers with a positive width and height", "the campus is framed by the union of the venue footprints");
-	}
-	let V = () => {
-		let e = /* @__PURE__ */ new Map();
-		for (let e of I) {
-			e.parsed = void 0;
-			for (let t of e.levels) t.surviving = !1;
-			for (let t of e.aux) t.surviving = !1;
-		}
-		for (let t of R) if (!(!t.claimable || !t.id || !t.name || L.has(t))) for (let n of t.levels) {
-			if (!n.ok) continue;
-			let r = n.value.layer, i = e.get(r);
-			if (i) {
-				C("level-layer-claimed", `${n.at}.layer`, `"${r}" is already used by ${i.label} (${i.role})`, "level dropped; a layer belongs to at most one venue and one role");
-				continue;
-			}
-			e.set(r, {
-				label: t.label,
-				role: "level"
-			}), n.surviving = !0;
-		}
-		for (let t of R) {
-			if (!t.claimable || !t.id || !t.name || L.has(t) || !t.levels.some((e) => e.surviving)) continue;
-			let n = 0;
-			for (let r of t.aux) {
-				if (!r.ok) continue;
-				let i = r.value, a = e.get(i.layer);
-				if (a) {
-					C("aux-layer-claimed", `${r.at}.layer`, `"${i.layer}" is already used by ${a.label} (${a.role})`, "entry dropped; a layer is a level, an aux layer, or neither — never two");
-					continue;
-				}
-				if (i.render === "marker" && n > 0) {
-					C("aux-marker-duplicate", `${r.at}.render`, "is a second marker layer for this venue", "at most one per venue; extras dropped, the first wins");
-					continue;
-				}
-				e.set(i.layer, {
-					label: t.label,
-					role: "aux"
-				}), r.surviving = !0, i.render === "marker" && n++;
-			}
-		}
-		return e;
-	}, H = (e) => {
-		var t;
-		if (e.contour) return e.contour;
-		let r = I.indexOf(e), i = e.aux.filter((e) => e.ok && e.value.render === "scene" && e.value.replacesDefault !== !1), a = new Map(i.filter((e) => e.surviving).map((e) => [e.value.layer, e])), s = [];
-		for (let e of (t = o[r]) == null ? [] : t) {
-			let t = a.get(e.layer);
-			if (!(t != null && t.surviving)) continue;
-			let n = (n) => E("footprint-source-unusable", `${t.at}.layer`, `scene layer "${e.layer}" ${n}`, "the next valid replacing scene is tried, then the level-rect hull"), { extraction: r } = e;
-			if (!r.ring) {
-				n(r.unusableElementKinds.length > 0 ? `draws no usable <path>; only paths are footprint sources, and it draws ${r.unusableElementKinds.map((e) => `<${e}>`).join(", ")}` : "could not supply a valid contour");
-				continue;
-			}
-			let i = w(r.ring);
-			if (!i.ring) {
-				var c;
-				n((c = i.issue) == null ? "could not supply a valid contour" : c);
-				continue;
-			}
-			s.push({
-				candidate: t,
-				layer: e.layer,
-				ring: i.ring,
-				boundsFallback: r.boundsFallback
-			});
-		}
-		s.length > 1 && O("footprint-source-ambiguous", `${e.at}.layers`, `multiple replacing scene layers provide contours: ${s.map(({ layer: e }) => `"${e}"`).join(", ")}`, `the first in plan-layer order, "${s[0].layer}", wins`);
-		let l = s[0];
-		if (l) return l.boundsFallback && E("footprint-bounding-box", `${l.candidate.at}.layer`, `scene layer "${l.layer}" uses its bounding box for the venue contour`, "camera, tap target, and size bounds may extend beyond the artwork"), l.ring;
-		let u = T(e.levels, n);
-		return u.length >= 3 && e.expectedSceneLayers.length > 0 && E("footprint-source-fallthrough", `${e.at}.contour`, "replacing scene contour unavailable; using the level-rect hull", "bounds, camera target, tap target, and the size axis changed source"), u;
-	};
-	for (;;) {
-		let e = A(() => (V(), R.find((e) => e.claimable && !L.has(e) && e.levels.some((e) => e.surviving) && H(e).length < 3)));
-		if (!e) break;
-		H(e), C("footprint-underivable", `${e.at}.contour`, "no valid polygon can be derived", `venue ${e.label} dropped entirely`), L.add(e);
-	}
-	let U = V();
-	for (let t of I) {
-		var W, G;
-		if (!t.claimable || !t.id || !t.name || L.has(t)) continue;
-		let n = t.levels.filter((e) => e.surviving);
-		if (n.length === 0) {
-			C("venue-levels-all-dropped", `${t.at}.levels`, "no level survives validation", `venue ${t.label} dropped entirely`);
-			continue;
-		}
-		let i = H(t), a = t.levels.filter((e) => e.value.initial === !0), o = n.filter((e) => e.value.initial === !0);
-		a.some((e) => !e.surviving) && E("level-initial-dropped", `${a.find((e) => !e.surviving).at}.initial`, "initial level was dropped", "the lowest surviving ordinal is initial"), t.levels.filter((e) => e.value.ordinal === 0).length > 0 && !n.some((e) => e.value.ordinal === 0) && O("level-ground-dropped", `${t.at}.levels`, "the ordinal 0 (ground) level was dropped", "cross-venue routing into this venue is likely broken (§13); the venue also boots on an upper floor"), o.length > 1 && O("level-initial-duplicate", `${t.at}.levels`, `${o.length} levels are marked initial`, "at most one per venue; the SDK takes the first");
-		let s = (W = o[0]) == null ? n.reduce((e, t) => t.value.ordinal < e.value.ordinal ? t : e) : W, c = new Set(n.map((e) => e.value.layer)), l = [];
-		for (let e of t.entrances) {
-			if (!c.has(e.value.layer)) {
-				C("entrance-level-dropped", `${e.at}.layer`, `level "${e.value.layer}" did not survive validation`, "entrance dropped; the venue falls back to its remaining doors, then to marker-point targeting");
-				continue;
-			}
-			l.push({ ...e.value });
-		}
-		let u = i.map((e) => ({
-			x: e.x,
-			y: e.y
-		}));
-		t.parsed = {
-			id: t.id,
-			name: t.name,
-			order: t.order,
-			levels: n.map((e) => ({
-				layer: e.value.layer,
-				ordinal: e.value.ordinal,
-				name: e.value.name,
-				initial: e === s
-			})),
-			contour: u,
-			markerPoint: (G = t.markerPoint) == null ? e(u) : G,
-			bounds: r.fromPoints(u),
-			detailMinSizePx: t.detailMinSizePx,
-			markerMaxSizePx: t.markerMaxSizePx,
-			entrances: l,
-			auxLayers: t.aux.filter((e) => e.surviving).map(({ value: e }) => {
-				var t, n;
-				let r = (t = e.replacesDefault) == null || t;
-				return {
-					layer: e.layer,
-					render: e.render,
-					replacesDefault: r,
-					suppressesLabel: (n = e.suppressesLabel) == null ? e.render === "scene" && r : n,
-					minSizePx: e.minSizePx,
-					maxSizePx: e.maxSizePx
-				};
-			})
-		};
-	}
-	let K = [];
-	for (let e of I) if (!e.parsed) for (let t of e.referencedLayers) K.includes(t) || K.push(t);
-	let q = [];
-	for (let e of I) e.parsed && q.push(e.parsed);
-	if (M.length > 0 && q.length === 0) return C("venues-all-dropped", "venues", "no venue survived validation", "plan loads as single-venue"), S([], s, []);
-	let J = K.filter((e) => !U.has(e));
-	return J.length > 0 && C("plan-layers-quarantined", "venues", `quarantined unclaimed layer${J.length === 1 ? "" : "s"}: ${J.map((e) => `"${e}"`).join(", ")}`, "hidden from venue and ordinary layer rendering"), S(q, s, J, z);
-}
-//#endregion
-export { l as n, E as r, m as t };