@expofp/floorplan 0.0.0-experimental.cf063fc

package/dist/esm/services/url-dispatch.js

@@ -0,0 +1,707 @@
+/**
+ * URL ⇄ state adapter — binds the pure legacy-URL grammar (`parseLegacyQuery` /
+ * `serializeSelection`, `@expofp/config`) to the stores and the public
+ * `FloorPlan` methods. All catalog lookups, MobX plumbing and legacy quirks
+ * live here, in named functions, so the grammar stays testable and the sync
+ * layer (`url-sync.ts`) stays store-free.
+ *
+ * Reading: `dispatchFromUrl` runs at boot (layers loaded), on browser
+ * back/forward, and from the public `applyParameters` — it replays the URL
+ * into state, preferring public `FloorPlan` methods where one matches 1:1.
+ * Writing: one MobX autorun serializes the current selection back into the
+ * address bar through the single writer. Both directions speak the same
+ * grammar, which keeps shortcuts bidirectional.
+ *
+ * Besides the URL, the DECLARATIVE config nodes (flags, heatmap, camera,
+ * visibility — merged by `loadConfig` from manifest/options/query) apply from
+ * here too (`applyDeclarativeConfig`), in every mode: `ignoreQuery` gates only
+ * the URL reading and writing (`initUrlRouting`).
+ *
+ * LEGACY GRAMMAR — frozen. This adapter is the ONLY legitimate consumer of the
+ * codec's parse side (`parseLegacyQuery` and the `Legacy*` types; lint-enforced
+ * elsewhere in floorplan). Do not add keys or forms — new URL capabilities are
+ * born in `UrlConfigSchema` (config keys) or `IntentsSchema` (intent arms).
+ */
+import { applyIntents, getConfig, parseDeprecatedUrlParams, parseFromUrlTolerant, parseIntentsFromUrl, parseLegacyQuery, serializeIntentToUrl, serializeSelection, } from '@expofp/config';
+import { Box } from '@expofp/geometry';
+import { UrlConfigSchema, } from '@expofp/schema';
+import { safeDecode } from '@expofp/utils';
+import { runInAction } from 'mobx';
+import { applyKioskMode } from '../components/Kiosk/kiosk-mode';
+import { recoverKioskFromUrlPrams } from '../components/Kiosk/recoverKioskFromUrlPrams';
+import { LEGACY_PREVIEW_MODE_STORAGE_KEY, LEGACY_VIEWER_MODE_STORAGE_KEY, PREVIEW_MODE_STORAGE_KEY, VIEWER_MODE_STORAGE_KEY, } from '../constants';
+import data from '../data';
+import { dispatchJourneyLink } from '../journey';
+import store, { uiState } from '../store';
+import { BoothBase } from '../store/BoothStore';
+import { CurrentPosition, extractRoute } from '../store/RouteStore';
+import { enterVenueFromMapSettings } from '../store/venue-selection';
+import { eventScopedValue } from '../tools/event-scoped-cache.js';
+import { setConsentSettings } from '../tools/gtag';
+import logger from '../tools/logger';
+import { areLayersEnabled } from '../utils/areLayersEnabled';
+import { brand } from '../utils/brand';
+import { cameraToMapSettings } from '../utils/camera-map-settings';
+import { handleCustomCommand } from '../utils/customCommands';
+import { formatEventTitle, formatPlaceholderTitle } from '../utils/event-title';
+import { getMostFrequent } from '../utils/getMostFrequent';
+import { heatmapEnabled } from '../utils/heatmap-enabled';
+import isOwnDomain from '../utils/is-own-domain';
+import { isLocalStorageAvailable } from '../utils/localStorage';
+import { planAutorun, planWhen } from '../utils/plan-reactions.js';
+import { stripTrackingParams } from '../utils/trackingParams';
+import { rewriteMultiSlugQuery } from './multi-slug';
+import { currentSearch, disableUrlWrites, initUrlSync, pushQuery, replaceQuery } from './url-sync';
+/** Suppresses the URL autorun while a dispatch is mutating state from the URL. */
+let syncSuppressed = false;
+/** True while the first-load dispatch replays the boot URL. */
+let bootDispatch = false;
+/**
+ * Apply the declarative config nodes onto the runtime state — the presentation
+ * flags and heatmap engagement now, camera and visibility on first layers
+ * load. Runs in EVERY mode, before `initUrlRouting`: `ignoreQuery` isolates
+ * the floor plan from the page URL (`loadConfig` already left the URL slice
+ * out of the effective config), not from its own manifest/options config.
+ */
+export function applyDeclarativeConfig() {
+    applyRuntimeConfigFlags(getConfig());
+    // First load only: a 2D/3D switch remounts the map and re-flips
+    // layersLoaded, and must not re-snap the boot camera (`when` fires once,
+    // then disposes). Registered before initUrlRouting's `when`, so on a shared
+    // boot the declarative nodes land before the dispatch replays the query and
+    // whatever that dispatch selects wins the final view.
+    planWhen(() => store.layerStore.layersLoaded, () => {
+        // the declarative boot camera (manifest / options / ?camera[…]= query)
+        const bootCamera = getConfig().camera;
+        if (Object.keys(bootCamera).length) {
+            applyMapSettings(cameraToMapSettings(bootCamera));
+        }
+        // the declarative boot visibility (manifest / options / ?visibility[…]=
+        // query). The store method, not the public setVisibility — boot must not
+        // toast. Runs after init-ui's sticky '___visibility' restore, so a
+        // configured visibility overrides the persisted one, and re-persists.
+        const bootVisibility = getConfig().visibility;
+        if (Object.keys(bootVisibility).length) {
+            uiState.setVisibility(bootVisibility);
+        }
+    });
+}
+export function initUrlRouting(offHistory) {
+    initUrlSync({ offHistory, onNavigate: () => dispatchFromUrl({ backForward: true }) });
+    applyOneShots();
+    executeCustomCommand();
+    // first load only, like the declarative `when` above — a map remount must
+    // not replay the URL over the visitor's current state, and the sync
+    // autoruns must register exactly once
+    planWhen(() => store.layerStore.layersLoaded, () => {
+        if (store.urlFilterManager && !store.urlFilterManager.isInitialized) {
+            store.urlFilterManager.initialize();
+        }
+        bootDispatch = true;
+        try {
+            dispatchFromUrl();
+        }
+        finally {
+            bootDispatch = false;
+        }
+        planAutorun(syncTitle);
+        planAutorun(syncUrl);
+        if (uiState.viewerMode) {
+            uiState.menu = true;
+        }
+    });
+}
+/** The public `FloorPlan.applyParameters` — replay a legacy query at runtime. */
+export function applyParameters(queryRaw = '') {
+    replaceQuery('?' + safeDecode(queryRaw.toString()));
+    if (!store.layerStore.layersLoaded) {
+        executeCustomCommand();
+        // `when`, not a reaction: replay once on first load — a later map remount
+        // re-flips layersLoaded and must not replay a stale query
+        planWhen(() => store.layerStore.layersLoaded, () => applyRuntimeParameters(queryRaw));
+    }
+    else {
+        applyRuntimeParameters(queryRaw);
+    }
+}
+function applyRuntimeParameters(queryRaw) {
+    const search = '?' + safeDecode(queryRaw);
+    // config-slice keys arriving at runtime can't merge into the frozen config —
+    // apply their runtime equivalents instead, mirroring the boot path
+    // (`applyDeclarativeConfig` + the config-intents run in load.ts)
+    const slice = parseUrlConfigSlice(search);
+    // canonical intents in either spelling, in boot's merge order: bracketed
+    // `intents[…]` entries before shortcut keys before the deprecated alias
+    const canonicalIntents = [...(slice.intents ?? []), ...parseIntentsFromUrl(search).intents];
+    // TEMPORARY, with the `@expofp/config` shim: the runtime path must honor
+    // the aliases the boot path folds into the frozen config. The shim drops an
+    // alias whose canonical key rides in the same query — no conflicts below.
+    const { intents: aliasIntents = [], ...deprecatedFields } = parseDeprecatedUrlParams(search, {
+        visibility: slice.visibility,
+        consent: slice.consent,
+        intents: canonicalIntents,
+    });
+    applyRuntimeConfigFlags(slice);
+    applyRuntimeConfigFlags(deprecatedFields); // only its `noOverlay` arm can fire
+    const consent = slice.consent ?? deprecatedFields.consent;
+    if (consent) {
+        setConsentSettings(consent);
+    }
+    if (slice.camera && Object.keys(slice.camera).length) {
+        applyMapSettings(cameraToMapSettings(slice.camera));
+    }
+    if (slice.visibility && Object.keys(slice.visibility).length) {
+        uiState.setVisibility(slice.visibility);
+    }
+    applyOneShots();
+    dispatchFromUrl();
+    // intents run last, after the dispatch settles the primary state
+    const intents = [...canonicalIntents, ...aliasIntents];
+    if (intents.length) {
+        // the public-API view of the instance — the same contract load.ts hands
+        // to applyIntents (the class type's CurrentPosition param is the store
+        // class, the intent arm carries the public plain shape)
+        applyIntents(store.fp, intents);
+    }
+}
+/* ── URL → state ───────────────────────────────────────────────────────────── */
+function executeCustomCommand() {
+    const search = currentSearch();
+    const slug = search.length > 1 ? safeDecode(search.substring(1)) : '';
+    return handleCustomCommand(slug);
+}
+/**
+ * `backForward`: a browser back/forward onto an existing history entry
+ * (`restoreEntry`). Boot and `applyParameters` run the URL's intents
+ * themselves, after this dispatch.
+ */
+function dispatchFromUrl(options = {}) {
+    syncSuppressed = true;
+    // the reset lives in `finally`: a store method throwing mid-dispatch on
+    // exotic input must not leave the write autorun suppressed for the rest
+    // of the session
+    try {
+        // the kiosk anchor rides along any deep link and re-applies on every
+        // navigation (the double decode mirrors the legacy reader)
+        const searchParams = new URLSearchParams(safeDecode(window.location.search));
+        recoverKioskFromUrlPrams(searchParams);
+        const { primary } = parseLegacyQuery(currentSearch());
+        // In heatmap mode the heatmap-query residue never dispatches as a select:
+        // the canonical `?heatmap[…]=` keys are config-owned (stripped from the
+        // slug), leaving either an empty slug or just the access token (`t=…`, not
+        // a config key) — replaying that as a select would stomp the boot search
+        // state the yah list rides on (init-heatmap's `selectSearch(' ')`) or flash
+        // the raw token as search text. The legacy `?heatmap=true` slug keeps its
+        // tokens and flows through `fp.select`'s own `heatmap=true` guard exactly
+        // as before; non-select primaries (`?kiosk=1&heatmap=true`) keep
+        // dispatching, as they always did.
+        const inertHeatmapQuery = primary.type === 'select' &&
+            (!primary.slug || /^t=[^&]*$/.test(primary.slug)) &&
+            (uiState.heatmap || uiState.heatmapYah);
+        if (!executeCustomCommand() && !inertHeatmapQuery) {
+            if (options.backForward) {
+                restoreEntry(primary);
+            }
+            else {
+                applyPrimary(primary);
+            }
+        }
+        // after the primary: the journey link is a config-owned key, so the legacy
+        // grammar hands us `ownedByConfig` and leaves the endpoints to us
+        applyJourneyLink();
+    }
+    finally {
+        syncSuppressed = false;
+    }
+    if (options.backForward) {
+        // a rewrite of this entry replaces it, and the next change is compared
+        // with what the entry shows — not with the selection the visitor left
+        const { exhibitor, booth, eventItem } = selectionFromState();
+        const saved = savedSelection();
+        saved.exhibitor = exhibitor;
+        saved.booth = booth;
+        saved.eventItem = eventItem;
+    }
+    syncUrl();
+    syncTitle();
+}
+/**
+ * The journey deep link (`?journey[to]=…&journey[from]=…`) — what a scanned
+ * kiosk QR or a desktop hand-off opens as. Only the two identifiers travel, so
+ * replaying them into the route is the whole dispatch: the ordinary journey
+ * path (`currentJourney`) re-plans from that route on THIS device, with its
+ * plan, its venues and its position. A code printed a week ago therefore
+ * answers with the plan as it is now.
+ *
+ * Runs on every navigation, like the kiosk anchor above it: the link may arrive
+ * at boot, on back/forward, or through `applyParameters`.
+ */
+function applyJourneyLink() {
+    const link = dispatchJourneyLink(currentSearch(), {
+        // not the public selectRoute: a journey link may name no origin at all
+        // (the device's own anchor fills it downstream), which the method rejects
+        selectRoute: (from, to) => store.routeStore.selectRoute(extractRoute(from, to, [])),
+    });
+    if (link) {
+        logger.log('Journey deep link', link);
+    }
+}
+/**
+ * Restore an existing history entry on browser back/forward. A plain
+ * `?sessions` opens the list with its filters off, and of the entry's intents
+ * only `showSessions` replays — the one the URL writer emits. Any other is a
+ * one-time command left from the boot URL (`?changeLanguage=de`), which must
+ * not run again.
+ */
+function restoreEntry(primary) {
+    if (primary.type === 'list' && primary.list === 'sessions') {
+        store.fp.showSessions();
+    }
+    else {
+        applyPrimary(primary);
+    }
+    const { intents } = parseIntentsFromUrl(currentSearch());
+    applyIntents(store.fp, intents.filter((intent) => intent.name === 'showSessions'));
+}
+function applyPrimary(primary) {
+    const fp = store.fp;
+    switch (primary.type) {
+        case 'kiosk':
+            // null: a value other than 1/0 — consume the branch and do nothing
+            if (primary.enabled !== null) {
+                applyKioskMode(uiState, primary.enabled);
+            }
+            return;
+        case 'list':
+            fp.showList(primary.list);
+            return;
+        case 'tour':
+            fp.selectTour(primary.tourId);
+            return;
+        case 'planner':
+            // a link that opens the planner together with a filter keeps the filter
+            if (bootDispatch)
+                store.searchButtonsStore.keepFiltersOnNextNavigation();
+            fp.openPlanner({
+                items: primary.items,
+                from: primary.from,
+                fromBookmarks: primary.fromBookmarks,
+            });
+            return;
+        case 'route': {
+            // not the public selectRoute: a shared route may miss its FROM (the kiosk
+            // anchor fills it downstream), which the method rightly rejects
+            store.routeStore.setOnlyAccessible(primary.accessible);
+            const route = extractRoute(primary.from ?? '', primary.to ?? '', primary.waypoints);
+            // a link that opens a route together with a filter keeps the filter;
+            // a route from a booth to itself is dropped by selectRoute and opens
+            // nothing, so it must not leave the hold armed
+            if (bootDispatch && !(route.from && route.from === route.to)) {
+                store.searchButtonsStore.keepFiltersOnNextNavigation();
+            }
+            store.routeStore.selectRoute(route);
+            store.uiState.setIsMultiPointRoute(primary.waypoints.length > 0);
+            if (primary.title) {
+                store.uiState.setRouteTitle(primary.title);
+            }
+            return;
+        }
+        case 'selectExhibitors':
+            // the 250ms delay is a legacy boot quirk of this deep link — kept here,
+            // not in the general-purpose method
+            setTimeout(() => fp.selectExhibitor(primary.values), 250);
+            return;
+        case 'ownedByFilters':
+            logger.log('Skipping filter parameters in dispatchFromUrl (owned by URLFilterManager)');
+            return;
+        case 'ownedByConfig':
+            // the whole query is config-slice / intent-shortcut keys, consumed by
+            // loadConfig at boot and applyRuntimeParameters at runtime — replaying
+            // it as an empty select would close whatever is open
+            return;
+        case 'select':
+            fp.select(primary.slug);
+            return;
+    }
+}
+/**
+ * The body of `FloorPlan.showPathway`. Lives here from the days the retired
+ * `?pathway=` deep link shared it; the multi-point-tour header that link
+ * could also raise is `ToursStore.launchTour`'s job now.
+ */
+export function applyPathway(options) {
+    const { pathwayId, boothIds, exhibitorIds } = options;
+    const directBooths = store.boothStore.booths.filter((b) => boothIds.includes(b.externalId));
+    const exhibitorBooths = store.exhibitorStore.exhibitors
+        .filter((e) => exhibitorIds.includes(e.externalId))
+        .flatMap((e) => e.booths);
+    const allBooths = [...directBooths, ...exhibitorBooths];
+    if (areLayersEnabled()) {
+        const layerName = getMostFrequent(allBooths.map((b) => b.layer.name));
+        if (layerName) {
+            store.fp.activateFloor({ name: layerName });
+        }
+    }
+    if (boothIds.length > 0 || exhibitorIds.length > 0) {
+        store.fp.highlightEntities([...boothIds, ...exhibitorIds]);
+    }
+    store.layerStore.showPathWay(pathwayId);
+    if (allBooths.length > 0) {
+        runInAction(() => {
+            store.uiState.moveToRect = Box.fromUnion(...allBooths.map((b) => b.rect).filter(Boolean));
+            store.uiState.rollReset = true;
+        });
+    }
+}
+/* ── One-shot boot effects (the former processURLParams) ───────────────────── */
+function applyOneShots() {
+    const { oneShots } = parseLegacyQuery(currentSearch());
+    for (const shot of oneShots) {
+        applyOneShot(shot);
+    }
+    // the third-party tracking scrub — the one pre-dispatch rewrite left, it
+    // needs the raw string (URLSearchParams would mangle a route slug's `:`)
+    const cleanedSearch = stripTrackingParams(currentSearch());
+    if (cleanedSearch !== null) {
+        replaceQuery('?' + cleanedSearch);
+    }
+    if (uiState.previewExhibitor) {
+        replaceQuery('?' + uiState.previewExhibitor.slug);
+    }
+    rewriteMultiSlug();
+}
+function applyOneShot(shot) {
+    switch (shot.type) {
+        case 'heatmap':
+            // the legacy ?heatmap=true&type=yah translation of the config.heatmap node
+            engageHeatmapMode(shot.yah);
+            return;
+        case 'blueDot': {
+            const currentPosition = new CurrentPosition(shot.x, shot.y, store.layerStore.findLayer(shot.layer ?? '')?.name, undefined, shot.lat, shot.lng);
+            // first load only — `when` fires once (immediately if already loaded);
+            // a map remount re-flips layersLoaded and must not re-place the dot
+            planWhen(() => store.layerStore.layersLoaded, () => store.routeStore.selectCurrentPosition(currentPosition, true, 1));
+            return;
+        }
+        case 'viewerMode':
+            // disable clears the preference (it does not persist a sticky "off"),
+            // and clears the legacy key too — a stale legacy value would otherwise
+            // resurrect the mode through the UIState fallback read
+            if (isLocalStorageAvailable) {
+                if (shot.enabled) {
+                    localStorage.setItem(VIEWER_MODE_STORAGE_KEY, 'true');
+                }
+                else {
+                    localStorage.removeItem(VIEWER_MODE_STORAGE_KEY);
+                    localStorage.removeItem(LEGACY_VIEWER_MODE_STORAGE_KEY);
+                }
+            }
+            return;
+        case 'previewMode':
+            if (isLocalStorageAvailable) {
+                if (shot.enabled) {
+                    localStorage.setItem(PREVIEW_MODE_STORAGE_KEY, 'true');
+                }
+                else {
+                    localStorage.removeItem(PREVIEW_MODE_STORAGE_KEY);
+                    localStorage.removeItem(LEGACY_PREVIEW_MODE_STORAGE_KEY);
+                }
+            }
+            return;
+        case 'uiScale':
+            // a sticky per-browser preference (persisted by setUIScale), same family
+            // as viewermode/previewMode above — NOT a FloorPlan method on purpose:
+            // its home is the localStorage config layer, the URL only seeds it
+            // (retirement plan §4.5)
+            if (shot.scale !== null) {
+                store.uiState.setUIScale(shot.scale, true);
+            }
+            else {
+                logger.warn(`Invalid ui-scale parameter: ${shot.raw}. ` + `Must be a number between 0.8 and 1.4.`);
+            }
+            return;
+        case 'resetUiScale':
+            store.uiState.resetUIScale();
+            return;
+    }
+}
+/**
+ * Engage heatmap mode — the `config.heatmap` node and the legacy
+ * `?heatmap=true` one-shot land here alike. Freezes the URL for the whole
+ * session FIRST (legacy contract: the heatmap tokens must survive in the
+ * address bar), then bundles a stripped-down presentation for the yah variant.
+ *
+ * TIMING: the freeze must beat the session's first URL write — the
+ * pre-dispatch rewrites at the end of `applyOneShots` (the tracking-param
+ * scrub, the preview-exhibitor and multi-slug rewrites) and, later, `syncUrl`'s
+ * serialization of an empty selection. That is why the config node applies from
+ * `applyRuntimeConfigFlags` — `applyDeclarativeConfig` runs it before
+ * `initUrlRouting`'s one-shots at boot, `applyRuntimeParameters` before its
+ * own — NOT from the layersLoaded boot block that the camera/visibility nodes
+ * use (layersLoaded fires after those rewrites). `initUrlSync` keeps the boot
+ * freeze via its one-way `writesDisabled` ratchet.
+ */
+function engageHeatmapMode(yah) {
+    disableUrlWrites();
+    if (yah) {
+        uiState.heatmapYah = true;
+        uiState.monochrome = true;
+        uiState.hideLogoInBooth = true;
+        uiState.hideHeaderLogo = true;
+        uiState.disableBookmarked = true;
+    }
+    else {
+        uiState.heatmap = true;
+    }
+}
+/**
+ * Legacy share links may join several exhibitor slugs with `&` (or an encoded
+ * `%26`); rewrite each recognizable slug to the exhibitor's display name so the
+ * search fallback shows readable text. The multi-slug decision and the part
+ * rules (a `key=value` config/intent param is never a slug — a lone slug
+ * riding with one must reach the dispatch intact and select) live in the pure
+ * `rewriteMultiSlugQuery`.
+ */
+function rewriteMultiSlug() {
+    const rewritten = rewriteMultiSlugQuery(currentSearch(), (part) => {
+        const exhibitor = store.exhibitorStore.exhibitors.find((x) => x.slug === part || x.externalId === part);
+        return exhibitor?.name;
+    });
+    if (rewritten !== null) {
+        replaceQuery(rewritten);
+    }
+}
+/**
+ * The presentation flags live on the config (any layer can set them); this maps
+ * them onto the runtime observables once at boot — and again for a query passed
+ * to `applyParameters`, where the config is already frozen. Only `noOverlay`
+ * historically accepted an explicit `false`; the rest only ever switch on.
+ */
+function applyRuntimeConfigFlags(flags) {
+    if (flags.noOverlay !== undefined)
+        uiState.hideOverlay = flags.noOverlay;
+    if (flags.monochrome)
+        uiState.monochrome = true;
+    if (flags.hideHeaderLogo)
+        uiState.hideHeaderLogo = true;
+    if (flags.hideLogoInBooth)
+        uiState.hideLogoInBooth = true;
+    if (flags.disableFeatured) {
+        store.exhibitorStore.exhibitors.forEach((ex) => (ex.featured = false));
+    }
+    if (flags.disableBookmarked)
+        uiState.disableBookmarked = true;
+    if (flags.disableGps)
+        store.routeStore.setGpsTrackingEnabled(false);
+    // the declarative heatmap node (manifest / ?heatmap[…]= query; the legacy
+    // ?heatmap=true stays a one-shot and never reaches the config). Applied
+    // here so the URL freeze precedes the session's first write — see
+    // engageHeatmapMode's TIMING note.
+    if (flags.heatmap && heatmapEnabled(flags.heatmap)) {
+        engageHeatmapMode(flags.heatmap.variant === 'yah');
+    }
+}
+function parseUrlConfigSlice(search) {
+    return parseFromUrlTolerant(UrlConfigSchema, search).value;
+}
+/* ── State → URL (the single writing autorun) ──────────────────────────────── */
+/**
+ * The selection the last URL write recorded — push vs. replace turns on
+ * whether it changed. Per event because the entries are the live plan's store
+ * objects: comparing the next event's selection against them would both pin
+ * the dead graph and make the first write of a new plan look like a change
+ * that never happened (ADR-0011).
+ */
+const savedSelection = eventScopedValue(() => ({
+    exhibitor: null,
+    booth: null,
+    eventItem: null,
+}));
+function syncUrl() {
+    const { selection, exhibitor, booth, eventItem } = selectionFromState();
+    // the legacy filter keys (?categories= / ?poiType(s)= / ?exhibitors=true)
+    // are the filter manager's — an empty selection with active filters means
+    // the filter query IS the URL. Serializing '' over it would stomp the
+    // filter manager's write (their MobX ordering decided the address bar);
+    // emitting the exact same string makes the two writers commute.
+    const filterSearch = store.urlFilterManager.filterSearch();
+    const sessionsSearch = sessionsFiltersSearch(selection);
+    // read the observables above unconditionally so the autorun keeps tracking
+    // them even while a dispatch suppresses the write
+    if (syncSuppressed)
+        return;
+    const newQuery = sessionsSearch || serializeSelection(selection) || filterSearch;
+    if (currentSearch() === newQuery)
+        return;
+    const saved = savedSelection();
+    if (exhibitor !== saved.exhibitor || booth !== saved.booth || eventItem !== saved.eventItem) {
+        pushQuery(newQuery);
+    }
+    else {
+        replaceQuery(newQuery);
+    }
+    saved.exhibitor = exhibitor;
+    saved.booth = booth;
+    saved.eventItem = eventItem;
+}
+/**
+ * The sessions list's active filters as the `showSessions` intent — `''` when
+ * the list is not showing or no filter is on, leaving the legacy `?sessions`
+ * (the frozen grammar has no filter form). Tracks and venues go by id: stable
+ * across renames, and never holding the `&` the legacy parser splits a
+ * decoded query on. The ids are sorted: one link per filter set, whatever the
+ * click order.
+ */
+function sessionsFiltersSearch(selection) {
+    if (selection.type !== 'list' || selection.list !== 'sessions')
+        return '';
+    const { selectedTracks, selectedVenues, date, timeOfDay, showBookmarksOnly, showLiveOnly } = store.sessionsFilterStore.state.filters;
+    const filters = {};
+    if (selectedTracks.value.length)
+        filters.tracks = sortedIds(selectedTracks.value);
+    if (selectedVenues.value.length)
+        filters.venues = sortedIds(selectedVenues.value);
+    if (date.value !== 'all')
+        filters.date = date.value;
+    // the time of day narrows the list only on today's date
+    if (date.value === 'today' && timeOfDay.value !== 'all')
+        filters.time = timeOfDay.value;
+    if (showBookmarksOnly.value)
+        filters.bookmarked = true;
+    if (showLiveOnly.value)
+        filters.live = true;
+    if (!Object.keys(filters).length)
+        return '';
+    return '?' + serializeIntentToUrl({ name: 'showSessions', args: [filters] });
+}
+function sortedIds(ids) {
+    return [...ids].sort((left, right) => left - right).map(String);
+}
+/** Map the observable UI state to a selection descriptor of the URL grammar. */
+function selectionFromState() {
+    const exhibitor = uiState.selectedExhibitor;
+    const booth = uiState.selectedBooth;
+    const eventItem = uiState.selectedEventItem;
+    const route = uiState.selectedRoute;
+    const speaker = uiState.selectedSpeaker;
+    const setKiosk = uiState.setKioskModeEnabled;
+    const list = uiState.list;
+    let selection;
+    if (list.type === 'route-planner' && !exhibitor && !booth && !eventItem) {
+        const planner = store.routePlannerStore;
+        selection = {
+            type: 'planner',
+            fromBookmarks: planner.source === 'bookmarks',
+            // Only entities with a slug are persisted in the planner URL; others are omitted.
+            items: planner.items.map((item) => item.entity.slug).filter(Boolean),
+            from: planner.startPoint?.slug || undefined,
+        };
+    }
+    else if (route && !uiState.isMultiPointRoute) {
+        // ArbitraryPoint (kiosk anchor / CP-derived "Your Location") has no slug and
+        // shouldn't appear in shareable URLs anyway — omit it. On the receiving
+        // side, kiosk coords are smuggled separately via `setKioskUrlParams`, and
+        // `selectRoute` fills the empty FROM slot back from `uiState.kioskData`.
+        selection = {
+            type: 'route',
+            to: route.to instanceof BoothBase ? route.to.slug : undefined,
+            from: route.from instanceof BoothBase ? route.from.slug : undefined,
+            accessible: store.routeStore.onlyAccessible,
+            waypoints: route.waypoints?.map((w) => w.slug),
+        };
+    }
+    else if (exhibitor) {
+        selection = { type: 'slug', slug: exhibitor.slug };
+    }
+    else if (booth) {
+        selection = { type: 'slug', slug: booth.slug };
+    }
+    else if (eventItem) {
+        selection = { type: 'slug', slug: eventItem.slug };
+    }
+    else if (speaker) {
+        selection = { type: 'slug', slug: speaker.slug };
+    }
+    else if (setKiosk) {
+        selection = { type: 'none' };
+    }
+    else {
+        switch (list.type) {
+            case 'bookmarks':
+            case 'visited':
+            case 'sessions':
+            case 'exhibitors':
+            case 'speakers':
+            case 'tours':
+            case 'language':
+                selection = { type: 'list', list: list.type };
+                break;
+            case 'category':
+                selection = { type: 'slug', slug: uiState.selectedCategory?.slug ?? '' };
+                break;
+            case 'search':
+                selection = { type: 'slug', slug: list.text || '' };
+                break;
+            case 'filter':
+                selection = { type: 'filter', key: list.query.key, value: list.query.value };
+                break;
+            case 'multi-point-tour':
+                selection = { type: 'tour', tourId: list.tourId };
+                break;
+            default:
+                throw new Error('Unkown list.type');
+        }
+    }
+    return { selection, exhibitor, booth, eventItem };
+}
+function syncTitle() {
+    // See is-own-domain.ts: skip on third-party pages that merely embedded us.
+    if (!isOwnDomain)
+        return;
+    const exhibitor = uiState.selectedExhibitor;
+    const eventItem = uiState.selectedEventItem;
+    const speaker = uiState.selectedSpeaker;
+    let title = '';
+    if (exhibitor)
+        title = exhibitor.name;
+    else if (eventItem)
+        title = eventItem.name;
+    else if (speaker)
+        title = speaker.name;
+    else if (uiState.list.type === 'search' && uiState.list.text)
+        title = '`' + (uiState.list.text || '') + '`';
+    else if (uiState.list.type === 'multi-point-tour' && uiState.tourTitle)
+        title = uiState.tourTitle;
+    if (title.length)
+        title += ' – ';
+    title += formatEventTitle(data, brand) ?? formatPlaceholderTitle(window.location.hostname, brand);
+    document.title = title;
+}
+/* ── Camera (map settings) application ─────────────────────────────────────── */
+/**
+ * Apply a map-settings patch through the observable (the Map component's
+ * reaction drives the renderer once it is ready), plus the boot-time floor
+ * activation the reaction alone historically couldn't provide: at first
+ * dispatch the Map may not be mounted yet, so the floor named by the settings
+ * is switched here directly.
+ */
+function applyMapSettings(settings) {
+    try {
+        uiState.setMapSettings(settings);
+        // On a venue-model plan the venue owns level activation: entering a venue
+        // destination focuses the venue and opens the addressed level in one move,
+        // so the plain layer toggle below must not also run.
+        const enteredVenueDestination = enterVenueFromMapSettings(store.venueStore, settings.venue, settings.z);
+        if (enteredVenueDestination)
+            return;
+        if (settings.z) {
+            const layer = store.layerStore.layers.find((l) => l.name === settings.z);
+            if (layer) {
+                store.layerStore.updateVisibility(layer, true);
+            }
+        }
+    }
+    catch (err) {
+        console.error('Failed to process map settings.', err);
+    }
+}