@expofp/floorplan 0.0.0-experimental.2d6c681 → 0.0.0-experimental.6dabc65

package/dist/esm/tools/sdk-telemetry.js

@@ -0,0 +1,122 @@
+import { peekConfig } from '@expofp/config';
+import debug from 'debug';
+/**
+ * SDK telemetry, sent while the `sdkTelemetry` flag is on to the intake the
+ * playbook's `development/sdk-telemetry.md` describes. The intake has no rate
+ * limit, so position batches go one request at a time, at least a second
+ * apart, and further apart while the intake keeps failing. An event the intake
+ * answered is never sent again, whatever the answer. Position items carry the
+ * `selectCurrentPosition` arguments as the host passed them, coordinates included.
+ */
+const log = debug('efp:sdk-telemetry');
+/** The last segment names this SDK as the source in Loki. */
+const INTAKE_URL = 'https://sdk-telemetry.expofp.com/sdk-data/floorplan-sdk-web';
+/** Public by nature in a browser: per the playbook it only keeps junk out. */
+const INTAKE_TOKEN = 'KaptzDWTgJ_GXhb5Jg7ByTW0KK_poitr21X_-IcJeE4';
+/** The localStorage queue of `selectCurrentPosition` calls; the expo ends the key. */
+const POSITION_QUEUE_KEY = 'efp-sdk-telemetry-positions:';
+/** The queue keeps the newest calls past this, which also holds a batch under the intake's 1 MiB. */
+const MAX_QUEUED_POSITIONS = 3_000;
+/** The least time between two position requests; each failure in a row doubles it, up to the max. */
+const MIN_SEND_INTERVAL_MS = 1_000;
+const MAX_SEND_INTERVAL_MS = 60_000;
+/** A position send is scheduled or in flight: anything queued meanwhile goes with the next one. */
+let positionSendBusy = false;
+/** When the last position request started, by `performance.now()`. */
+let lastPositionSendAt = -Infinity;
+/** Position requests in a row the intake did not accept. */
+let failedPositionSends = 0;
+/** Sends one event while SDK telemetry is on. Never throws. */
+export function sendSdkTelemetry(event) {
+    const config = enabledConfig();
+    if (config)
+        void post(config.expo, { event });
+}
+/**
+ * Queues one `selectCurrentPosition` call in localStorage, where it outlives
+ * the page, and sends the queue as one event once the previous request is done
+ * and the interval since it has passed. A batch that never reached the intake
+ * (offline, network error) stays queued for the next send.
+ */
+export function queuePositionTelemetry(item) {
+    const config = enabledConfig();
+    if (!config)
+        return;
+    const key = POSITION_QUEUE_KEY + config.expo;
+    storeQueue(key, [...readQueue(key), { ts: new Date().toISOString(), ...item }]);
+    schedulePositionSend();
+}
+function schedulePositionSend() {
+    if (positionSendBusy)
+        return;
+    positionSendBusy = true;
+    const interval = Math.min(MIN_SEND_INTERVAL_MS * 2 ** failedPositionSends, MAX_SEND_INTERVAL_MS);
+    const wait = Math.max(0, lastPositionSendAt + interval - performance.now());
+    setTimeout(() => void sendPositionQueue(), wait);
+}
+async function sendPositionQueue() {
+    const config = enabledConfig();
+    const key = POSITION_QUEUE_KEY + (config?.expo ?? '');
+    const items = readQueue(key);
+    // offline, the queue stays as it is until a later call schedules a send
+    if (!config || items.length === 0 || navigator.onLine === false) {
+        positionSendBusy = false;
+        return;
+    }
+    storeQueue(key, []);
+    lastPositionSendAt = performance.now();
+    const status = await post(config.expo, { event: 'selectCurrentPosition', items });
+    // a batch that never reached the intake goes back, ahead of calls queued meanwhile
+    if (status === undefined)
+        storeQueue(key, [...items, ...readQueue(key)]);
+    failedPositionSends = status === 200 ? 0 : failedPositionSends + 1;
+    positionSendBusy = false;
+    if (readQueue(key).length > 0)
+        schedulePositionSend();
+}
+/** Resolves to the intake's HTTP status, or `undefined` when the request never reached it. */
+async function post(expo, fields) {
+    try {
+        const response = await fetch(INTAKE_URL, {
+            method: 'POST',
+            headers: { Authorization: `Bearer ${INTAKE_TOKEN}`, 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                ts: new Date().toISOString(),
+                version: typeof __BUILD_INFO__ === 'undefined' ? undefined : __BUILD_INFO__.version,
+                expo,
+                ...fields,
+            }),
+        });
+        if (response.status !== 200) {
+            log('event refused', response.status, await response.text().catch(() => ''));
+        }
+        return response.status;
+    }
+    catch (error) {
+        log('event not sent', error);
+        return undefined;
+    }
+}
+function readQueue(key) {
+    try {
+        return JSON.parse(localStorage.getItem(key) ?? '[]');
+    }
+    catch {
+        return [];
+    }
+}
+function storeQueue(key, items) {
+    try {
+        if (items.length === 0)
+            localStorage.removeItem(key);
+        else
+            localStorage.setItem(key, JSON.stringify(items.slice(-MAX_QUEUED_POSITIONS)));
+    }
+    catch (error) {
+        log('position queue not stored', error);
+    }
+}
+function enabledConfig() {
+    const config = peekConfig();
+    return config?.sdkTelemetry === true ? config : undefined;
+}

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.2d6c681",
+  "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.2d6c681",
-    "@expofp/debug": "0.0.0-experimental.2d6c681",
-    "@expofp/geometry": "0.0.0-experimental.2d6c681",
-    "@expofp/renderer": "0.0.0-experimental.2d6c681",
-    "@expofp/resolve": "0.0.0-experimental.2d6c681",
-    "@expofp/schema": "0.0.0-experimental.2d6c681",
-    "@expofp/ui": "0.0.0-experimental.2d6c681",
-    "@expofp/utils": "0.0.0-experimental.2d6c681",
-    "@expofp/wayfinding": "0.0.0-experimental.2d6c681"
+    "@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-DKpIy-87.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-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 };