@expofp/floorplan 0.0.0-experimental.2d6c681

package/dist/esm/journey/types.d.ts

@@ -0,0 +1,294 @@
+import type { LatLng, Point2Like } from '@expofp/geometry';
+import type { MapsProvider } from '@expofp/schema';
+/**
+ * The journey value the planner returns and every consumer — UI, URL dispatch,
+ * SDK event — reads. Deliberately free of MobX, the DOM, and the wayfinding
+ * engine: a Journey is a plain value derived from inputs (`plan-journey.ts`).
+ *
+ * Vocabulary is normative (CONTEXT.md § Journeys).
+ */
+/**
+ * The external maps app an external leg is handed off to. Defined by the schema
+ * package, which owns the authored shape of the producer's `mapsProvider`
+ * override, and re-exported here so journey consumers have one name for it.
+ */
+export type { MapsProvider };
+/** What the planner needs to know about the device to pick a provider. */
+export interface JourneyPlatform {
+    /** iOS / iPadOS — the platforms whose default maps app is Apple Maps. */
+    readonly isApplePlatform: boolean;
+}
+/** The graph's answer for one endpoint pair — the sole journey trigger (ADR-0010). */
+export type GraphConnectivity = 'routable' | 'unreachable';
+/**
+ * An authored door of a venue, carried in both spaces at once: plan-local,
+ * which is where indoor cost is measured, and geographic, which is what leaves
+ * for the maps app. Projection happens once, on the way in — the planner never
+ * touches the plan's anchors itself.
+ */
+export interface JourneyEntrance {
+    /** Plan-local position — the space booths and contours are in. */
+    readonly local: Point2Like;
+    /** The same door on the ground. */
+    readonly geo: LatLng;
+    /** Authored display name; absent doors borrow the venue's own name. */
+    readonly name?: string;
+    /**
+     * The plan layer the door stands on. Together with {@link local} this is the
+     * whole of what an indoor leg hands the wayfinding engine — an ordinary route
+     * endpoint, the kiosk anchor's shape exactly. Absent on a door whose level the
+     * plan never produced, which costs the leg its route but not the journey.
+     */
+    readonly layerName?: string;
+}
+/**
+ * Which kind of place one end of a journey is (CONTEXT.md § Journeys). A venue
+ * is entered and so has doors to enter by; an outdoor PoI is reached and has
+ * none, ever.
+ *
+ * Explicit rather than inferred from emptiness, because a venue whose author
+ * wrote no entrances and a PoI look identical from the outside and mean
+ * opposite things: the venue's missing indoor leg is a degraded leg, the PoI's
+ * is the shape of the place. Only this can tell them apart.
+ */
+export type JourneyPlaceKind = 'venue' | 'outdoor-poi';
+/**
+ * One end of a journey as the planner sees it: identity plus the geo point a
+ * journey targets. A venue and an outdoor PoI are both places (CONTEXT.md §
+ * Journeys), and either may stand at either end.
+ */
+export interface JourneyPlace {
+    readonly id: string;
+    readonly name: string;
+    /**
+     * What kind of place this is. `placeKind`, not `kind`, so it can travel
+     * unchanged onto a journey's origin ref, where `kind` already names which of
+     * the three sources the journey started from.
+     */
+    readonly placeKind: JourneyPlaceKind;
+    /**
+     * The place's target point in geographic coordinates. Absent when the plan
+     * carries no usable GPS anchors — the place is then not journeyable at all.
+     */
+    readonly geo?: LatLng;
+    /**
+     * The place's authored doors, if it has any. Absent and empty mean the same
+     * thing — the place is targeted at the point above, which is permanent
+     * behavior for plans that never author entrances, not a missing feature.
+     */
+    readonly entrances?: readonly JourneyEntrance[];
+}
+/** A place as a journey refers to it. */
+export interface JourneyPlaceRef {
+    readonly id: string;
+    readonly name: string;
+    readonly placeKind: JourneyPlaceKind;
+}
+/**
+ * Where a journey starts. The three sources are interchangeable downstream —
+ * the planner treats them alike everywhere except the handoff URL, where a
+ * known place is worth telling the provider about and a live position is not.
+ */
+export type JourneyOriginKind = 
+/** The user's own position, tracked live — mobile navigation. */
+'live-position'
+/** The fixed point a kiosk stands at. */
+ | 'kiosk-anchor'
+/** A from-booth the user picked, planning rather than walking. */
+ | 'selected-booth';
+/** The anchor a journey starts from: which source it came from, and its place. */
+export interface JourneyOrigin {
+    readonly kind: JourneyOriginKind;
+    readonly place: JourneyPlace;
+}
+/** A journey's origin as the journey refers to it. */
+export interface JourneyOriginRef extends JourneyPlaceRef {
+    readonly kind: JourneyOriginKind;
+}
+/** Where the external leg drops the user off. */
+export interface ExternalLegTarget {
+    readonly geo: LatLng;
+    /**
+     * What the point is: the destination venue's chosen door, its marker point
+     * for a venue that authors none, or the outdoor PoI itself. The marker is a
+     * degraded leg, and permanent behavior for plans that never author entrances;
+     * the PoI is not degraded at all — there is nothing there to enter, and no
+     * authoring could add it.
+     */
+    readonly kind: 'venue-marker' | 'venue-entrance' | 'outdoor-poi';
+    /** Human-readable context for the target: the door's name, or the place's. */
+    readonly label: string;
+    /**
+     * The chosen door's authored name. Absent on a marker target, and on a door
+     * whose author left it unnamed — in both cases {@link label} names the venue.
+     */
+    readonly entrance?: string;
+}
+/**
+ * How the external leg is sketched on our own map: the gap it spans and how
+ * wide that gap is. Never a street path — we draw the shape of the trip and
+ * leave the streets to the provider (ADR-0010), so the only geometry here is
+ * the two endpoints and the distance between them.
+ */
+export interface ExternalLegConnector {
+    /**
+     * Where the sketch starts: the origin place's chosen exit, or — for a place
+     * that authors no door — its marker point. The same point the handoff URL
+     * carries as its origin, so the street preview begins at the door the exit
+     * leg walks the visitor to.
+     */
+    readonly from: LatLng;
+    /** The external leg's target point — the same point the handoff URL carries. */
+    readonly to: LatLng;
+    /** Straight-line (great-circle) distance between the endpoints, in metres. */
+    readonly distanceMeters: number;
+}
+/**
+ * The stage delegated to an external maps provider. Its URL carries both
+ * endpoints when the journey starts from a known place — a kiosk anchor or a
+ * picked from-booth — so the provider shows the true A-to-B street preview, and
+ * the destination only from a live position, so street navigation starts where
+ * the user really is. No travel-mode hint is passed either way (ADR-0010).
+ */
+export interface ExternalLeg {
+    readonly kind: 'external';
+    readonly target: ExternalLegTarget;
+    /** What the leg looks like on our map before the handoff. */
+    readonly connector: ExternalLegConnector;
+    readonly provider: MapsProvider;
+    /** Ready-to-open provider URL — what the external handoff opens. */
+    readonly url: string;
+}
+/**
+ * An indoor stage of a journey: the walk out of the origin venue to its chosen
+ * exit, and the walk from the destination venue's chosen entrance to the booth.
+ *
+ * A leg carries a door, not a path. Routing it is the engine's job and the
+ * engine never learns what an entrance is: the door reaches it as an ordinary
+ * route endpoint — a plan-local point on a level — which is the kiosk anchor's
+ * shape exactly (ADR-0010, contract §6.1). The other end of each leg is
+ * whatever the visitor already asked for: the journey origin, or the booth.
+ *
+ * An indoor leg exists only when its venue authored a door the plan can place.
+ * A venue that authored none has no leg here at all — the visitor leaves and
+ * arrives the way every unauthored plan has always had them do, which is
+ * permanent product surface rather than a missing piece.
+ */
+export interface IndoorLeg {
+    readonly kind: 'exit' | 'arrival';
+    /**
+     * The venue walked through — the origin venue leaving, the destination
+     * arriving. `venue`, not `place`: an indoor leg exists only where there is
+     * something to walk through, so the narrower word is the precise one here.
+     */
+    readonly venue: JourneyPlaceRef;
+    /** The chosen door, and the route endpoint the engine is given. */
+    readonly door: JourneyEntrance;
+    /** What to call the door: its authored name, or its venue's when unnamed. */
+    readonly label: string;
+}
+/** The walk from the journey origin to the origin venue's chosen exit. */
+export interface ExitLeg extends IndoorLeg {
+    readonly kind: 'exit';
+}
+/** The walk from the destination venue's chosen entrance to the booth. */
+export interface ArrivalLeg extends IndoorLeg {
+    readonly kind: 'arrival';
+}
+/** Journey legs, in the order they are walked. */
+export type JourneyLeg = ExitLeg | ExternalLeg | ArrivalLeg;
+/** A trip between two journey places, presented as an ordered sequence of legs. */
+export interface Journey {
+    readonly origin: JourneyOriginRef;
+    readonly destination: JourneyPlaceRef;
+    /**
+     * What the visitor asked to be taken to — the booth the route was requested
+     * for, which the arrival leg walks them to. {@link destination} is only the
+     * place it stands in, and naming the trip after that would drop the booth the
+     * visitor picked. The place's own name when the endpoint names nothing finer.
+     */
+    readonly destinationName: string;
+    /**
+     * The legs in walking order: exit, external, arrival. Only the external leg
+     * is always there — an indoor leg needs a venue with an authored door on its
+     * side, and without one it is dropped rather than faked. Two different
+     * absences read the same here: a venue that authored no door is a degraded
+     * leg, an outdoor PoI simply has nothing to walk through. A journey of one
+     * leg is as normal as a journey of three, and never an error.
+     */
+    readonly legs: readonly JourneyLeg[];
+}
+/** Why no journey applies; each reason leaves today's behavior untouched. */
+export type NoJourneyReason = 
+/** The `crossVenueJourneys` flag is off. */
+'disabled'
+/** The graph routes between the endpoints, so the built-in route stands. */
+ | 'graph-connected'
+/**
+ * Both endpoints sit at one place — ordinary indoor routing. Kind and id
+ * together: venue ids and booth slugs are both slug-shaped and live in
+ * different namespaces, so an id alone could call two places one.
+ */
+ | 'same-place'
+/** An endpoint resolves to no place (single-venue plans, unknown layers). */
+ | 'place-unknown';
+/** What the planner decided for one route request. */
+export type JourneyPlan = 
+/** No journey: today's behavior stands, whether that is a route or its ordinary failure. */
+{
+    readonly outcome: 'none';
+    readonly reason: NoJourneyReason;
+}
+/**
+ * Journeys apply, but a place has no GPS anchor to target — an honest dead
+ * end rather than a broken journey.
+ */
+ | {
+    readonly outcome: 'no-route';
+    readonly reason: 'place-not-geo-anchored';
+} | {
+    readonly outcome: 'journey';
+    readonly journey: Journey;
+};
+/** Everything the planner decides from. Pure in, pure out. */
+export interface JourneyRequest {
+    /** The `crossVenueJourneys` config flag. Off → the planner never proposes a journey. */
+    readonly enabled: boolean;
+    readonly connectivity: GraphConnectivity;
+    /**
+     * The anchor the journey starts from — live position, kiosk anchor or a
+     * picked from-booth, all three treated alike; null when it resolves to no
+     * place.
+     */
+    readonly origin: JourneyOrigin | null;
+    /**
+     * Where the journey origin sits on the plan — the kiosk's anchor, the
+     * visitor's live position, the from-booth. What the exit door is chosen
+     * against: the door closest to it indoors is the one to walk out through.
+     * Absent when the origin has no position of its own, which leaves the choice
+     * to the direction of the destination place.
+     */
+    readonly originPoint?: Point2Like;
+    /** The place the destination sits at; null when it resolves to no place. */
+    readonly destination: JourneyPlace | null;
+    /**
+     * What the route was asked for, by name — the booth inside the destination
+     * place. Absent leaves the journey named after the place itself.
+     */
+    readonly destinationName?: string;
+    /**
+     * Where the destination itself sits on the plan — the booth or point the
+     * route was asked for. What the arrival door is chosen against: the door
+     * closest to it indoors is the one the visitor should walk in through.
+     * Absent when the endpoint has no position of its own, which leaves the
+     * choice to the approach from the origin place.
+     */
+    readonly destinationPoint?: Point2Like;
+    readonly platform: JourneyPlatform;
+    /**
+     * The producer's `mapsProvider` config override. Absent — the usual case —
+     * leaves the choice to the platform.
+     */
+    readonly providerOverride?: MapsProvider;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/esm/journey/types.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/load-dev.d.ts

@@ -0,0 +1,44 @@
+/**
+ * TEMPORARY dev logging + console playground — DELETE this file together with
+ * its import in `load.ts`.
+ *
+ * Logs the effective config and the eagerly-loaded `fp.svg.js` payload while
+ * `pnpm dev:floorplan` runs. The lazy parts (layer `$ref`s — js evaluated to
+ * json by `@expofp/resolve` — and other data files) load only when called from
+ * the console. None of this feeds the app: `resolve()` evaluates scripts into
+ * a sandbox, so `window.__fp*` and the script-tag loader stay untouched.
+ *
+ * Play with it from the console:
+ *
+ *   __efpDev.config                                  // frozen effective config
+ *   __efpDev.fpSvgJs                                 // evaluated fp.svg.js payload
+ *   __efpDev.refs                                    // layer name -> { $ref }
+ *   __efpDev.layers                                  // resolved payloads so far
+ *   await __efpDev.loadLayer('Venue')                // resolve one layer by name
+ *   await __efpDev.loadLayers()                      // resolve every layer ref
+ *   await __efpDev.loadDataFile('wf.data.js')        // any file next to fp.svg.js
+ *   await __efpDev.loadDataFile('booths.json')
+ *   await __efpDev.resolve({ $ref: 'https://…/fp.svg.js' }) // raw resolve, js or json
+ */
+import { type Config } from '@expofp/config';
+import { resolve } from '@expofp/resolve';
+import { type FpSvgJs, type FpSvgLayerJs, type FpSvgLayerJsRef } from '@expofp/schema';
+interface EfpDevPlayground {
+    config: Config;
+    fpSvgJs: FpSvgJs;
+    refs: Record<string, FpSvgLayerJsRef>;
+    layers: Record<string, FpSvgLayerJs>;
+    loadLayer: (name: string) => Promise<FpSvgLayerJs | undefined>;
+    loadLayers: () => Promise<Record<string, FpSvgLayerJs>>;
+    loadDataFile: <T = unknown>(fileName: string) => Promise<T>;
+    resolve: typeof resolve;
+}
+declare global {
+    interface Window {
+        /** @deprecated temporary dev playground, see `load-dev.ts` */
+        __efpDev?: EfpDevPlayground;
+    }
+}
+export declare function initLoadDev(config: Config): void;
+export {};
+//# sourceMappingURL=load-dev.d.ts.map

package/dist/esm/load-dev.js

@@ -0,0 +1,60 @@
+import { getResolved, resolve } from '@expofp/resolve';
+const TAG = '[efp-dev]';
+export function initLoadDev(config) {
+    const { fpSvgLayerJsRefs: refs } = config;
+    const fpSvgJs = config.fpSvgJsRef ? getResolved(config.fpSvgJsRef) : {};
+    console.group(`${TAG} config loaded`);
+    console.log('config:', config);
+    console.log('fp.svg.js (eager):', summarizeFpSvg(fpSvgJs), fpSvgJs);
+    const layerRows = (fpSvgJs.__fpLayers ?? []).map((layer) => ({
+        name: layer.name,
+        description: layer.description,
+        mode: layer.mode,
+        floorIndex: layer.floorIndex,
+        hasViewbox: layer.viewbox != null,
+        default: layer.name === fpSvgJs.__fpDefaultLayer,
+        $ref: refs[layer.name]?.$ref ?? '(inline in fp.svg.js)',
+    }));
+    if (layerRows.length)
+        console.table(layerRows);
+    console.log('layersMode:', fpSvgJs.__fpLayersMode, 'defaultLayer:', fpSvgJs.__fpDefaultLayer);
+    console.groupEnd();
+    const layers = {};
+    const loadLayer = async (name) => {
+        const ref = refs[name];
+        if (!ref) {
+            console.warn(`${TAG} no $ref for layer "${name}" — known:`, Object.keys(refs));
+            return undefined;
+        }
+        const started = performance.now();
+        const payload = await resolve(ref);
+        const elapsed = Math.round(performance.now() - started);
+        layers[name] = payload;
+        console.log(`${TAG} layer "${name}" ← ${ref.$ref} (${elapsed}ms)`, summarizeFpSvg(payload), payload);
+        return payload;
+    };
+    const loadLayers = async () => {
+        await Promise.all(Object.keys(refs).map(loadLayer));
+        return layers;
+    };
+    const loadDataFile = async (fileName) => {
+        const dataDir = config.fpSvgJsRef ? config.fpSvgJsRef.$ref.split(/[?#]/)[0].replace(/[^/]*$/, '') : '';
+        const url = `${dataDir}${fileName}`;
+        const started = performance.now();
+        const payload = await resolve({ $ref: url });
+        console.log(`${TAG} ${fileName} ← ${url} (${Math.round(performance.now() - started)}ms)`, payload);
+        return payload;
+    };
+    window.__efpDev = { config, fpSvgJs, refs, layers, loadLayer, loadLayers, loadDataFile, resolve };
+    console.log(`${TAG} playground ready — nothing loads until you ask; try:`, `await __efpDev.loadLayers()`, `| await __efpDev.loadLayer('${Object.keys(refs)[0] ?? 'name'}')`, `| await __efpDev.loadDataFile('wf.data.js')`);
+}
+function summarizeFpSvg(payload) {
+    return {
+        svgChars: payload.__fp?.length ?? 0,
+        paths: payload.__fpPaths?.length ?? 0,
+        fpVersion: payload.__fpVersion,
+        fpVer: payload.__fpSettings?.fpVer,
+        bearing: payload.__fpGeo?.properties?.config?.bearing,
+        keys: Object.keys(payload).join(', '),
+    };
+}

package/dist/esm/load.d.ts

@@ -0,0 +1,17 @@
+import './utils/silence-mobx-react-lite-warning';
+import { type Manifest, type Options } from '@expofp/config';
+import { type Ref } from '@expofp/resolve';
+import { type FloorPlan, type FloorPlanOptions } from './types';
+export declare function load(manifestRef: Manifest | Ref<Manifest>, options?: Options & FloorPlanOptions): Promise<FloorPlan>;
+declare global {
+    interface Window {
+        /** @deprecated */
+        ___fp?: FloorPlan;
+        /** @deprecated temporary placeholder for async initialization in iOS/Android SDK */
+        ___fpResolve?: (fp: FloorPlan) => void;
+        __expofpReady?: CustomEvent<{
+            floorplan: FloorPlan;
+        }>;
+    }
+}
+//# sourceMappingURL=load.d.ts.map

package/dist/esm/load.js

@@ -0,0 +1,244 @@
+import './utils/silence-mobx-react-lite-warning';
+import { applyIntents, loadConfig, setConfig, } from '@expofp/config';
+import { safeLocalStorage } from '@expofp/utils';
+import debug from 'debug';
+import { initHtmlHead } from './_misc_to_move/initHtmlHead';
+import { logBuildInfo } from './_misc_to_move/logBuildInfo';
+import { RUNTIME_LOADER_SPINNER_CLASS } from './constants.js';
+import FloorPlanLoader from './floorplan.loader';
+// import { initLoadDev } from './load-dev'; // TEMPORARY — delete together with load-dev.ts
+import { claimPlanSlot, disposePlan, registerPlanDisposer } from './plan-lifecycle.js';
+import reportError from './tools/report-error.js';
+import { brand } from './utils/brand';
+import { applyEventHead, buildEventHead } from './utils/event-head';
+import { formatEventTitle } from './utils/event-title';
+import isOwnDomain from './utils/is-own-domain';
+import { migrateLegacyStorageKeys } from './utils/legacy-storage-keys';
+const log = debug('efp:load');
+export async function load(manifestRef, options = {}) {
+    // One live plan per page (ADR-0011). Claimed before anything is fetched or
+    // built, so a host that loads a second event without destroying the first
+    // gets a rejected promise instead of a half-swapped world — and so does a
+    // host that fires two loads before the first has settled.
+    claimPlanSlot();
+    try {
+        return await loadPlan(manifestRef, options);
+    }
+    catch (error) {
+        // Nothing rendered, so nothing owns the page: hand the slot back rather
+        // than leaving the host unable to retry. A disposer bug must not mask why
+        // the load failed.
+        try {
+            disposePlan();
+        }
+        catch (teardownError) {
+            log('teardown after a failed load:', teardownError);
+        }
+        throw error;
+    }
+}
+async function loadPlan(manifestRef, options = {}) {
+    // Per plan; the browser ignores a duplicate registration of the same function.
+    window.addEventListener('error', reportError);
+    registerPlanDisposer(() => window.removeEventListener('error', reportError));
+    initHtmlHead();
+    logBuildInfo();
+    // Device diagnostics pull in Bowser, so keep them — and this module — out of
+    // the entry/loader chunk: load lazily, and only when efp:device is enabled.
+    if (debug('efp:device').enabled) {
+        void import('./_misc_to_move/logDeviceInfo')
+            .then((m) => m.logDeviceInfo())
+            .catch(() => {
+            /* empty */
+        });
+    }
+    const elementField = options.element;
+    let element;
+    if (typeof elementField === 'string') {
+        const queriedEl = document.querySelector(elementField);
+        if (!queriedEl) {
+            // console.warn(`Element not found for selector:`, elementField);
+            throw new Error(`Element not found for selector: ${elementField}`);
+        }
+        element = queriedEl;
+    }
+    else if (elementField) {
+        element = elementField;
+    }
+    else {
+        // try to find #floorplan element
+        element = document.getElementById('floorplan');
+        if (!element) {
+            element = document.createElement('div');
+            addRuntimeLoaderSpinner(element);
+            document.body.appendChild(element);
+        }
+    }
+    ensureDefaultStylesheet();
+    element.setAttribute('data-efp-floorplan-defaults', '');
+    // pull-to-refresh fires at the scrolling root, so it must be silenced there;
+    // overscroll-behavior on a descendant does not reach upward to the document
+    document.documentElement.style.overscrollBehavior ||= 'none';
+    document.body.style.overscrollBehavior ||= 'none';
+    requestAnimationFrame(() => {
+        element.style.backgroundColor = '#ebebeb';
+    });
+    // ahead of loadConfig, so its localStorage layer (and the debug panel)
+    // already see the schema-typed `efp-*` keys on browsers holding only the
+    // pre-schema `___*` preference keys
+    migrateLegacyStorageKeys();
+    let config;
+    try {
+        // safeLocalStorage: a cookie-blocked iframe boots without the storage
+        // layer instead of throwing SecurityError into the catch below
+        config = await loadConfig(manifestRef, options, window.location.search, safeLocalStorage() ?? undefined);
+        if (!config.fpSvgJsRef) {
+            throw new Error('No floor plan drawing: the manifest must set `legacyDataUrlBase` (live event) or `fpSvgJsRef` (offline copy)');
+        }
+    }
+    catch (error) {
+        // Pre-render failures (manifest/version/data.js fetch, validation, or a
+        // config with no drawing) land here — same end-user screen the loader
+        // shows when data.js never runs.
+        const { showEventNotFound } = await import('./tools/event-not-found');
+        showEventNotFound(element);
+        throw error;
+    }
+    log('config', config);
+    // A new event starts here: everything event-scoped is keyed by this config
+    // object, so nothing built for the previous plan is served past this line
+    // (ADR-0011, one live plan per page).
+    setConfig(config);
+    // The real title as soon as it's known, well before layersLoaded (see
+    // syncTitle in url-dispatch.ts, which re-applies this once selection/URL
+    // state can prefix it), together with the search-facing head (event-head.ts)
+    // that the bare event shell lacks. See is-own-domain.ts for the domain check.
+    if (isOwnDomain) {
+        const title = formatEventTitle(config, brand);
+        if (title)
+            document.title = title;
+        applyEventHead(document, buildEventHead(config), `${window.location.origin}/`);
+    }
+    // initLoadDev(config); // TEMPORARY — delete together with load-dev.ts
+    // TODO everything should be done inside FloorPlan class
+    // initialization should be async
+    const floorplan = new FloorPlanLoader(options, element);
+    const placeholderResolve = window.___fpResolve;
+    window['___fp'] = floorplan;
+    // `ready` rejects when the plan is destroyed before it finishes loading, so
+    // every branch below needs a catch: these are "the plan came up" side
+    // effects that must simply not fire on a cancelled load, and an uncaught
+    // one would reach the page as an unhandled rejection.
+    if (placeholderResolve) {
+        floorplan.ready
+            .then(() => placeholderResolve(floorplan))
+            .catch((error) => log('placeholder resolve skipped:', error));
+        delete window.___fpResolve;
+    }
+    floorplan.ready
+        .then(() => {
+        const event = new CustomEvent('expofp:ready', { detail: { floorplan } });
+        window.__expofpReady = event;
+        window.dispatchEvent(event);
+    })
+        .catch((error) => log('ready event skipped:', error));
+    // Config-carried intents (e.g. deep links from the page URL) run last —
+    // after onInit and the ready event — so they win over host init calls.
+    floorplan.ready
+        .then(() => applyIntents(floorplan, config.intents))
+        .catch((error) => log('config intents skipped:', error));
+    return floorplan;
+}
+function ensureDefaultStylesheet() {
+    const id = 'efp-floorplan-defaults';
+    if (document.getElementById(id))
+        return;
+    const styleEl = document.createElement('style');
+    styleEl.id = id;
+    // Prepended to <head> so user CSS (later in source order) wins on equal-specificity ties.
+    // Attribute selector keeps specificity low (0,1,0) — any #id or .class user rule beats it.
+    styleEl.textContent = `
+[data-efp-floorplan-defaults] {
+  position: fixed;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+  overflow: hidden;
+  touch-action: none;
+  overscroll-behavior: none;
+  background: #fff;
+  transition: background-color 2s ease;
+}`;
+    document.head.prepend(styleEl);
+}
+function addRuntimeLoaderSpinner(el) {
+    if (!document.adoptedStyleSheets)
+        return;
+    const className = RUNTIME_LOADER_SPINNER_CLASS;
+    const css = `
+.${className} {
+  position: fixed;
+  top: 50%;
+  left: 50%;
+  transform: translate(-50%, -50%);
+  opacity: 0;
+  z-index: 5;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  pointer-events: none;
+  transition: all 1s ease;
+}
+
+.${className} > svg {
+  width: 60px;
+  transform-origin: center;
+  animation: ${className}-rotate 2s linear infinite;
+}
+
+.${className} > svg > circle {
+  fill: none;
+  stroke: var(--color-primary, #2382f4);
+  stroke-dasharray: 1, 200;
+  stroke-dashoffset: 0;
+  stroke-linecap: round;
+  stroke-width: 2;
+  animation: ${className}-dash 1.5s ease-in-out infinite;
+}
+
+@keyframes ${className}-rotate {
+  100% {
+    transform: rotate(360deg);
+  }
+}
+
+@keyframes ${className}-dash {
+  0% {
+    stroke-dasharray: 1, 200;
+    stroke-dashoffset: 0;
+  }
+
+  50% {
+    stroke-dasharray: 90, 200;
+    stroke-dashoffset: -35px;
+  }
+
+  100% {
+    stroke-dashoffset: -125px;
+  }
+}`;
+    const sheet = new CSSStyleSheet();
+    sheet.replaceSync(css);
+    // Apply to document
+    document.adoptedStyleSheets = [...document.adoptedStyleSheets, sheet];
+    el.innerHTML = `<div class="${className}">
+    <svg viewBox="25 25 50 50">
+      <circle r="20" cy="50" cx="50"></circle>
+    </svg>
+  </div>`;
+    requestAnimationFrame(() => {
+        const loader = el.querySelector(`.${className}`);
+        loader?.style.setProperty('opacity', '1');
+    });
+}