@expofp/floorplan 0.0.0-experimental.cf063fc

package/dist/browser/venues-DKpIy-87.js

@@ -0,0 +1,447 @@
+(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-CK6wLW56.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 };

package/dist/browser/viewport-B7plho3P.js

@@ -0,0 +1,48 @@
+(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] = "8061fd30-b7d3-48a5-b02d-285dfa346e6c", e._sentryDebugIdIdentifier = "sentry-dbid-8061fd30-b7d3-48a5-b02d-285dfa346e6c");
+	} catch {}
+})();
+import { t as e } from "./LayerStore-CK6wLW56.js";
+import { l as t } from "./store-q_CTsixH.js";
+//#region src/components/Map/viewport.ts
+function n(e) {
+	return {
+		canvasToPlan: (t) => e.current.api.canvasToPlan(t),
+		planToCanvas: (t) => e.current.api.planToCanvas(t),
+		isVisible: (t) => e.current.api.isVisible(t)
+	};
+}
+function r(e) {
+	a = e;
+}
+function i() {
+	return a;
+}
+var a;
+function o(n) {
+	let r = i();
+	if (!n || !r) throw Error("Canvas not ready");
+	let a = r.canvasToPlan({
+		x: n.clientWidth / 2,
+		y: n.clientHeight / 2
+	});
+	if (!a) throw Error("The camera is not looking at the plan");
+	let o = t.venueStore.venueAt(a);
+	if (o) return {
+		x: a.x,
+		y: a.y,
+		z: o.activeLevel.layer.name
+	};
+	let s = t.layerStore.visible.find((t) => t.mode === e.TurnedOff || t.mode === e.TurnedOn);
+	return {
+		x: a.x,
+		y: a.y,
+		z: (s == null ? void 0 : s.name) || null
+	};
+}
+//#endregion
+export { r as i, n, i as r, o as t };

package/dist/esm/_misc_to_move/initHtmlHead.d.ts

@@ -0,0 +1,2 @@
+export declare function initHtmlHead(): void;
+//# sourceMappingURL=initHtmlHead.d.ts.map

package/dist/esm/_misc_to_move/initHtmlHead.js

@@ -0,0 +1,34 @@
+import { brand } from '../utils/brand';
+import { formatPlaceholderTitle } from '../utils/event-title';
+import isOwnDomain from '../utils/is-own-domain';
+export function initHtmlHead() {
+    if (typeof window === 'undefined' || typeof document === 'undefined') {
+        return;
+    }
+    const metaViewport = document.querySelector('meta[name="viewport"]');
+    if (!metaViewport) {
+        const meta = document.createElement('meta');
+        meta.name = 'viewport';
+        meta.content = 'width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no';
+        document.head.appendChild(meta);
+    }
+    // if favicon is not set, set it to default
+    const hasFavicon = () => !!document.querySelector('link[rel="icon"]');
+    if (!hasFavicon()) {
+        // dynamically import assets/favicon.png
+        import('../assets/favicon.png').then(({ default: faviconUrl }) => {
+            if (hasFavicon()) {
+                return;
+            }
+            const link = document.createElement('link');
+            link.rel = 'icon';
+            link.type = 'image/png';
+            link.href = faviconUrl;
+            document.head.appendChild(link);
+        });
+    }
+    // See is-own-domain.ts: skip on third-party pages that merely embedded us.
+    if (isOwnDomain && (!document.title || document.title === 'Document')) {
+        document.title = formatPlaceholderTitle(window.location.hostname, brand);
+    }
+}

package/dist/esm/_misc_to_move/logBuildInfo.d.ts

@@ -0,0 +1,2 @@
+export declare function logBuildInfo(): void;
+//# sourceMappingURL=logBuildInfo.d.ts.map

package/dist/esm/_misc_to_move/logBuildInfo.js

@@ -0,0 +1,35 @@
+export function logBuildInfo() {
+    // @ts-ignore
+    const buildInfo = __BUILD_INFO__;
+    if (buildInfo) {
+        const time = new Date(buildInfo.built);
+        console.info('%c⚡️[efp-runtime]%c v%c%s%c commit=%c%s%c branch=%c%s%c built=%c%s%c (%s)', 'color:#2382f4;font-weight:600', // efp-runtime
+        'color:inherit', 'color:#dcdcaa;font-weight:600', // version label
+        buildInfo.version, 'color:inherit', 'color:#9cdcfe', // commit label
+        buildInfo.commit, 'color:inherit', 'color:#ce9178', // branch label
+        buildInfo.branch, 'color:inherit', 'color:#b5cea8', // built label
+        buildInfo.built, 'color:inherit', timeAgoString(time));
+    }
+}
+function timeAgoString(date) {
+    // 1 day 2 hours 3 minutes ago
+    const now = new Date();
+    const diffMs = now.getTime() - date.getTime();
+    const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24));
+    const diffHours = Math.floor((diffMs / (1000 * 60 * 60)) % 24);
+    const diffMinutes = Math.floor((diffMs / (1000 * 60)) % 60);
+    const parts = [];
+    if (diffDays > 0) {
+        parts.push(`${diffDays} day${diffDays !== 1 ? 's' : ''}`);
+    }
+    if (diffHours > 0) {
+        parts.push(`${diffHours} hour${diffHours !== 1 ? 's' : ''}`);
+    }
+    if (diffMinutes > 0) {
+        parts.push(`${diffMinutes} minute${diffMinutes !== 1 ? 's' : ''}`);
+    }
+    if (parts.length === 0) {
+        return 'just now';
+    }
+    return parts.join(' ') + ' ago';
+}

package/dist/esm/_misc_to_move/logDeviceInfo.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Logs a one-line environment report — SDK build plus OS / browser / device —
+ * to the `efp:device` debug namespace.
+ *
+ * Hidden by default; enable it with `localStorage.debug = 'efp:device'` (or
+ * `efp:*`) and reload. Deliberately unstyled so support can ask a user to copy
+ * the line and send it when reporting an issue.
+ */
+export declare function logDeviceInfo(): Promise<void>;
+//# sourceMappingURL=logDeviceInfo.d.ts.map