@expofp/floorplan 0.0.0-experimental.cf063fc

package/dist/esm/hooks/useURLFilters.d.ts

@@ -0,0 +1,15 @@
+import { type URLFilters } from '../store/types';
+export declare const useURLFilters: () => {
+    currentFilters: {
+        categories: string[];
+        poiType: string | null;
+        exhibitors: boolean;
+        isActive: boolean;
+    };
+    setCategories: (categoryNames: string[]) => void;
+    setPoiType: (poiTypeName: string | null) => void;
+    clearAllFilters: () => void;
+    validateFilters: (filters: URLFilters) => boolean;
+    isInitialized: boolean;
+};
+//# sourceMappingURL=useURLFilters.d.ts.map

package/dist/esm/hooks/useURLFilters.js

@@ -0,0 +1,44 @@
+import { useObserver } from 'mobx-react-lite';
+import { useCallback, useEffect } from 'react';
+import store from '../store';
+// ET 2025-11-30: code change to test how it merges into vite-next
+export const useURLFilters = () => {
+    const { urlFilterManager, uiState } = store;
+    const currentFilters = useObserver(() => ({
+        categories: uiState.selectedCategoryFilters.map((cat) => cat.name),
+        poiType: uiState.selectedPoiTypeFilters.length > 0 ? uiState.selectedPoiTypeFilters[0].name : null,
+        exhibitors: urlFilterManager.currentFilters.exhibitors,
+        isActive: uiState.hasAppliedFilters || urlFilterManager.currentFilters.exhibitors,
+    }));
+    const setCategories = useCallback((categoryNames) => {
+        if (urlFilterManager.isInitialized) {
+            urlFilterManager.setCategories(categoryNames);
+        }
+    }, [urlFilterManager]);
+    const setPoiType = useCallback((poiTypeName) => {
+        if (urlFilterManager.isInitialized) {
+            urlFilterManager.setPoiType(poiTypeName);
+        }
+    }, [urlFilterManager]);
+    const clearAllFilters = useCallback(() => {
+        if (urlFilterManager.isInitialized) {
+            urlFilterManager.clearAllFilters();
+        }
+    }, [urlFilterManager]);
+    const validateFilters = useCallback((filters) => {
+        return urlFilterManager.validateFilters(filters);
+    }, [urlFilterManager]);
+    useEffect(() => {
+        if (!urlFilterManager.isInitialized) {
+            urlFilterManager.initialize();
+        }
+    }, [urlFilterManager]);
+    return {
+        currentFilters,
+        setCategories,
+        setPoiType,
+        clearAllFilters,
+        validateFilters,
+        isInitialized: urlFilterManager.isInitialized,
+    };
+};

package/dist/esm/index.d.ts

@@ -0,0 +1,3 @@
+export { load } from './load';
+export type * from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/index.js

@@ -0,0 +1,12 @@
+import { toDebugSettings } from '@expofp/config';
+import { registerSettings } from '@expofp/debug';
+import { LocalStorageConfigSchema } from '@expofp/schema';
+import reportError from './tools/report-error';
+window.addEventListener('error', reportError);
+window.__efpStyleElements = [];
+// Every LocalStorageConfigSchema field with a scalar editor is editable in
+// the debug panel — the panel edits the exact `efp-*` keys the config's
+// localStorage layer reads on the next load. Fields without an editor (so
+// far only the number-typed `uiScale`) are skipped by the derivation.
+registerSettings(toDebugSettings(LocalStorageConfigSchema));
+export { load } from './load';

package/dist/esm/intercom/bootIntercom.d.ts

@@ -0,0 +1,3 @@
+import type { IntercomContext } from './types';
+export declare function bootIntercom(ctx: IntercomContext): void;
+//# sourceMappingURL=bootIntercom.d.ts.map

package/dist/esm/intercom/bootIntercom.js

@@ -0,0 +1,47 @@
+/* eslint-disable */
+// Inline snippet like sentry.ts / gtag.ts — no @intercom/messenger-js-sdk dep (we publish to npm).
+import { intercomStore } from '../store';
+const INTERCOM_APP_ID = 'k5f7wyx2';
+let booted = false;
+export function bootIntercom(ctx) {
+    if (booted)
+        return;
+    booted = true;
+    const { subDomain, subscriptionStatus } = ctx;
+    const w = window;
+    // hide_default_launcher: true — Intercom won't render its own launcher in light DOM
+    // (it would visually pierce shadow-DOM overlays/modals regardless of in-shadow z-index,
+    // since the shadow tree paints atomically in the host's parent stacking context).
+    // We render a custom launcher inside the shadow root and trigger Intercom('show') on click.
+    w.intercomSettings = {
+        api_base: 'https://api-iam.intercom.io',
+        app_id: INTERCOM_APP_ID,
+        alignment: 'right',
+        hide_default_launcher: true,
+        expofp_subdomain: subDomain,
+        expofp_subscription_status: subscriptionStatus,
+    };
+    const i = function () {
+        i.c(arguments);
+    };
+    i.q = [];
+    i.c = function (args) {
+        i.q.push(args);
+    };
+    w.Intercom = i;
+    i('onUnreadCountChange', (n) => intercomStore.setUnreadCount(n));
+    const inject = () => {
+        const s = document.createElement('script');
+        s.type = 'text/javascript';
+        s.async = true;
+        s.src = `https://widget.intercom.io/widget/${INTERCOM_APP_ID}`;
+        s.onload = () => intercomStore.setEnabled(true);
+        document.head.appendChild(s);
+    };
+    if (document.readyState === 'complete') {
+        inject();
+    }
+    else {
+        window.addEventListener('load', inject, false);
+    }
+}

package/dist/esm/intercom/index.d.ts

@@ -0,0 +1,3 @@
+export { shouldLoadIntercom } from './shouldLoad';
+export type { IntercomContext } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/intercom/index.js

@@ -0,0 +1 @@
+export { shouldLoadIntercom } from './shouldLoad';

package/dist/esm/intercom/shouldLoad.d.ts

@@ -0,0 +1,4 @@
+import { type Config } from '@expofp/config';
+import { type IntercomContext } from './types';
+export declare function shouldLoadIntercom(data: Config): IntercomContext | null;
+//# sourceMappingURL=shouldLoad.d.ts.map

package/dist/esm/intercom/shouldLoad.js

@@ -0,0 +1,74 @@
+import { isKioskMode } from '../components/Kiosk/kiosk-mode';
+//i.e. checks host ends with .expofp.com
+function isExpofpHost() {
+    const parts = window.location.hostname.split('.');
+    return (parts.length >= 3 && parts[parts.length - 2] === 'expofp' && parts[parts.length - 1] === 'com');
+}
+function getSubDomain() {
+    if (!isExpofpHost())
+        return 'main';
+    return window.location.hostname.split('.')[0];
+}
+function getSubscriptionStatus(data) {
+    if (data?.free === true)
+        return 'Free';
+    const trialExpiresAt = data?.trialExpiresAt;
+    if (trialExpiresAt) {
+        const expires = new Date(trialExpiresAt).getTime();
+        if (!Number.isNaN(expires)) {
+            return Date.now() < expires ? 'Trial Active' : 'Trial Expired';
+        }
+    }
+    return 'Active';
+}
+// Dev-guard blocks yarn dev from registering visitor sessions in the real workspace;
+// bypass by passing ?__intercom_subdomain=... or ?__intercom_status=... in the URL.
+// Those two are request glue, not config keys.
+function isDevGuardActive() {
+    if (process.env.NODE_ENV === 'production')
+        return false;
+    const params = new URLSearchParams(window.location.search);
+    return !params.has('__intercom_subdomain') && !params.has('__intercom_status');
+}
+function applyDevOverrides(ctx) {
+    if (process.env.NODE_ENV === 'production')
+        return ctx;
+    const params = new URLSearchParams(window.location.search);
+    const subDomainOverride = params.get('__intercom_subdomain');
+    const statusOverride = params.get('__intercom_status');
+    const validStatuses = ['Active', 'Trial Active', 'Trial Expired', 'Free'];
+    const subscriptionStatus = statusOverride && validStatuses.includes(statusOverride)
+        ? statusOverride
+        : ctx.subscriptionStatus;
+    return {
+        subDomain: subDomainOverride ?? ctx.subDomain,
+        subscriptionStatus,
+    };
+}
+// Returns the Intercom context if the messenger should boot for this session, otherwise null.
+// Stays in the main bundle so callers can dynamic-import bootIntercom only when needed.
+export function shouldLoadIntercom(data) {
+    if (isDevGuardActive())
+        return null;
+    // Don't load when the widget is embedded on a third-party site
+    // (dev bypasses this via isDevGuardActive above).
+    if (process.env.NODE_ENV === 'production' && !isExpofpHost())
+        return null;
+    // Kiosk terminals are unattended displays — never boot the support chat there.
+    if (isKioskMode(data))
+        return null;
+    // Intercom needs network — skip in offline mode.
+    if (!window.navigator.onLine)
+        return null;
+    const ctx = applyDevOverrides({
+        subDomain: getSubDomain(),
+        subscriptionStatus: getSubscriptionStatus(data),
+    });
+    // Gating: load only on demo subdomain or for non-paying customers.
+    if (ctx.subDomain !== 'demo' &&
+        ctx.subscriptionStatus !== 'Free' &&
+        ctx.subscriptionStatus !== 'Trial Expired') {
+        return null;
+    }
+    return ctx;
+}

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

@@ -0,0 +1,6 @@
+export type SubscriptionStatus = 'Active' | 'Trial Active' | 'Trial Expired' | 'Free';
+export interface IntercomContext {
+    subDomain: string;
+    subscriptionStatus: SubscriptionStatus;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/esm/intercom/types.js

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

package/dist/esm/internal-settings.d.ts

@@ -0,0 +1,13 @@
+import { type Config } from '@expofp/config';
+/**
+ * Undocumented grey surface for the mobile SDKs (expofp/efp-app#1491): the
+ * allowlisted slice of the effective config, returned by
+ * `fp.getInternalSettings()` (`___fp.getInternalSettings()` from the native
+ * bridges). Deliberately absent from the public `FloorPlan` interface and the
+ * generated docs — not a public contract. Extend only by widening the Pick
+ * below; every field must have a named consumer in a mobile SDK repo (see the
+ * atlas).
+ */
+export type InternalSettings = Pick<Config, 'mobileLocationProvider'>;
+export declare function toInternalSettings(config: Config): InternalSettings;
+//# sourceMappingURL=internal-settings.d.ts.map

package/dist/esm/internal-settings.js

@@ -0,0 +1,6 @@
+export function toInternalSettings(config) {
+    // `null`, never `''`: the bridges read this as Kotlin `null` / Swift `nil`,
+    // so a blank value from the event data must not reach them as a string.
+    const provider = config.mobileLocationProvider?.trim();
+    return Object.freeze({ mobileLocationProvider: provider ? provider : null });
+}

package/dist/esm/journey/external-navigation.d.ts

@@ -0,0 +1,30 @@
+import type { FloorPlanExternalNavigationEvent } from '../types.js';
+import type { ExternalLeg, Journey } from './types.js';
+/** The external leg of a journey — the one stage there is a handoff for. */
+export declare const externalLegOf: (journey: Journey) => ExternalLeg | undefined;
+/** What the SDK knows when it offers the handoff to the host app. */
+export interface ExternalNavigationDispatch {
+    /** The journey being handed off, exactly as the planner returned it. */
+    readonly journey: Journey;
+    /** The journey deep link, when the app can name the journey's destination. */
+    readonly deepLink?: string;
+    /** The host's callback — absent in every embedding that never registered one. */
+    readonly onExternalNavigation?: (e: FloorPlanExternalNavigationEvent) => void;
+}
+/**
+ * The SDK event adapter: offer a journey's external handoff to the host app and
+ * report whether the host took it.
+ *
+ * The whole payload is read off the planner's `Journey` value — this decides
+ * nothing about the handoff, it only says what the planner already decided in
+ * the vocabulary a native host thinks in.
+ *
+ * Left alone, the SDK's default stands: `false` here means the caller opens the
+ * provider URL exactly as it did before the event existed, which is why an
+ * embedding written against an older SDK needs no update at all. A host that
+ * calls `preventDefault()` gets `true`, and the SDK opens nothing — the handoff
+ * is then the host's, typically as a native maps intent a WebView would
+ * otherwise mishandle.
+ */
+export declare function dispatchExternalNavigation({ journey, deepLink, onExternalNavigation, }: ExternalNavigationDispatch): boolean;
+//# sourceMappingURL=external-navigation.d.ts.map

package/dist/esm/journey/external-navigation.js

@@ -0,0 +1,38 @@
+/** The external leg of a journey — the one stage there is a handoff for. */
+export const externalLegOf = (journey) => journey.legs.find((leg) => leg.kind === 'external');
+/**
+ * The SDK event adapter: offer a journey's external handoff to the host app and
+ * report whether the host took it.
+ *
+ * The whole payload is read off the planner's `Journey` value — this decides
+ * nothing about the handoff, it only says what the planner already decided in
+ * the vocabulary a native host thinks in.
+ *
+ * Left alone, the SDK's default stands: `false` here means the caller opens the
+ * provider URL exactly as it did before the event existed, which is why an
+ * embedding written against an older SDK needs no update at all. A host that
+ * calls `preventDefault()` gets `true`, and the SDK opens nothing — the handoff
+ * is then the host's, typically as a native maps intent a WebView would
+ * otherwise mishandle.
+ */
+export function dispatchExternalNavigation({ journey, deepLink, onExternalNavigation, }) {
+    const leg = externalLegOf(journey);
+    if (!leg || !onExternalNavigation)
+        return false;
+    let handled = false;
+    onExternalNavigation({
+        destination: leg.target.geo,
+        context: {
+            originVenue: journey.origin.name,
+            destinationVenue: journey.destination.name,
+            entrance: leg.target.entrance,
+            label: leg.target.label,
+        },
+        url: leg.url,
+        deepLink,
+        preventDefault: () => {
+            handled = true;
+        },
+    });
+    return handled;
+}

package/dist/esm/journey/format-distance.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The distance label the external leg's connector carries: how wide the gap
+ * between the two venues is as the crow flies, in the units the plan is
+ * authored in.
+ *
+ * Journeys span the distances the wayfinding graph was never meant to cover, so
+ * the reading switches to the large unit — kilometres, miles — as soon as the
+ * gap reaches it, rather than quoting an attendee four-digit metres.
+ * @param distanceMeters - the connector's great-circle length, in metres
+ * @param planUnits - the plan's `units` attribute; anything but metres is feet
+ * @returns the label, or an empty string when the distance is not a number
+ */
+export declare function formatConnectorDistance(distanceMeters: number, planUnits: string | undefined): string;
+//# sourceMappingURL=format-distance.d.ts.map

package/dist/esm/journey/format-distance.js

@@ -0,0 +1,38 @@
+const FEET_PER_METER = 3.280_84;
+const FEET_PER_MILE = 5280;
+/** Below this the reading stays in the small unit; above it, the large one. */
+const METERS_PER_KILOMETER = 1000;
+const FEET_PER_TENTH_MILE = FEET_PER_MILE / 10;
+/**
+ * A distance reads with one decimal while it is small enough for the decimal to
+ * matter, and whole once it is not. `Math.round` on a scaled value drops a
+ * trailing zero on its own, so 9.95 km reads "10 km" rather than "10.0 km".
+ */
+const round = (value) => String(value < 10 ? Math.round(value * 10) / 10 : Math.round(value));
+/**
+ * The distance label the external leg's connector carries: how wide the gap
+ * between the two venues is as the crow flies, in the units the plan is
+ * authored in.
+ *
+ * Journeys span the distances the wayfinding graph was never meant to cover, so
+ * the reading switches to the large unit — kilometres, miles — as soon as the
+ * gap reaches it, rather than quoting an attendee four-digit metres.
+ * @param distanceMeters - the connector's great-circle length, in metres
+ * @param planUnits - the plan's `units` attribute; anything but metres is feet
+ * @returns the label, or an empty string when the distance is not a number
+ */
+export function formatConnectorDistance(distanceMeters, planUnits) {
+    if (!Number.isFinite(distanceMeters))
+        return '';
+    const meters = Math.max(0, distanceMeters);
+    // The unit is chosen from the rounded reading, so a gap that rounds up to the
+    // large unit's threshold reads "1 km" rather than "1000 m".
+    if (planUnits?.toLowerCase().trim() === 'm') {
+        const whole = Math.round(meters);
+        return whole < METERS_PER_KILOMETER
+            ? `${whole} m`
+            : `${round(meters / METERS_PER_KILOMETER)} km`;
+    }
+    const feet = Math.round(meters * FEET_PER_METER);
+    return feet < FEET_PER_TENTH_MILE ? `${feet} ft` : `${round(feet / FEET_PER_MILE)} mi`;
+}

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

@@ -0,0 +1,16 @@
+/**
+ * Journeys: the planner seam and the adapters that feed it.
+ *
+ * Everything here is pure — no MobX, no DOM (bar the one navigator read in
+ * `currentJourneyPlatform`) — so stores, UI, URL dispatch and the SDK event stay
+ * thin consumers of the `Journey` value the planner returns.
+ */
+export { dispatchExternalNavigation, externalLegOf, type ExternalNavigationDispatch, } from './external-navigation.js';
+export { formatConnectorDistance } from './format-distance.js';
+export { currentJourneyPlatform, detectJourneyPlatform, type JourneyContext, type JourneyDestinationEndpoint, type JourneyOriginEndpoint, type JourneyOutdoorPoi, type JourneyPlaceRecord, type JourneyPlaceSource, type PlatformProbe, readGraphConnectivity, resolveJourneyPlan, type RouteAttempt, } from './journey-context.js';
+export { buildJourneyLink, dispatchJourneyLink, type JourneyLink, type JourneyLinkTarget, parseJourneyLink, } from './journey-link.js';
+export { advanceJourneyStage, indoorLegOf, initialJourneyStage, type JourneyStage, type JourneyStageEvent, journeyStages, } from './journey-stage.js';
+export { buildExternalHandoffUrl, resolveMapsProvider } from './maps-provider.js';
+export { planJourney } from './plan-journey.js';
+export * from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/journey/index.js

@@ -0,0 +1,15 @@
+/**
+ * Journeys: the planner seam and the adapters that feed it.
+ *
+ * Everything here is pure — no MobX, no DOM (bar the one navigator read in
+ * `currentJourneyPlatform`) — so stores, UI, URL dispatch and the SDK event stay
+ * thin consumers of the `Journey` value the planner returns.
+ */
+export { dispatchExternalNavigation, externalLegOf, } from './external-navigation.js';
+export { formatConnectorDistance } from './format-distance.js';
+export { currentJourneyPlatform, detectJourneyPlatform, readGraphConnectivity, resolveJourneyPlan, } from './journey-context.js';
+export { buildJourneyLink, dispatchJourneyLink, parseJourneyLink, } from './journey-link.js';
+export { advanceJourneyStage, indoorLegOf, initialJourneyStage, journeyStages, } from './journey-stage.js';
+export { buildExternalHandoffUrl, resolveMapsProvider } from './maps-provider.js';
+export { planJourney } from './plan-journey.js';
+export * from './types.js';

package/dist/esm/journey/journey-context.d.ts

@@ -0,0 +1,140 @@
+import { type Point2Like } from '@expofp/geometry';
+import type { GpsConfig } from '../utils/gps.js';
+import type { GraphConnectivity, JourneyOriginKind, JourneyPlan, JourneyPlatform, MapsProvider } from './types.js';
+/** The venue-model slice the journey path reads. Narrow on purpose — no MobX here. */
+export interface JourneyPlaceSource {
+    readonly hasVenueModel: boolean;
+    venueOfLayer(layerName: string): JourneyPlaceRecord | null;
+}
+/** A door as the app models it: plan-local, like everything else in the model. */
+export interface JourneyPlaceEntranceRecord {
+    readonly point: Point2Like;
+    readonly name?: string;
+    /**
+     * The venue level the door stands on. Read down to its plan layer's name on
+     * the way through, which is all an indoor leg needs to hand the door to the
+     * wayfinding engine as an ordinary route endpoint.
+     */
+    readonly level?: {
+        readonly layer: {
+            readonly name: string;
+        };
+    };
+}
+/** A place as the app models it, before its target point reaches the ground. */
+export interface JourneyPlaceRecord {
+    readonly id: string;
+    readonly name: string;
+    /** Far-zoom pin anchor, plan-local — what a journey targets without doors. */
+    readonly markerPoint: Point2Like;
+    /** Authored doors; absent and empty alike leave the place on its marker point. */
+    readonly entrances?: readonly JourneyPlaceEntranceRecord[];
+}
+/** Everything the journey path needs besides the two route endpoints. */
+export interface JourneyContext {
+    readonly venues: JourneyPlaceSource;
+    /** The plan's georeference (`__fpGeo.properties.config`). */
+    readonly gpsConfig: GpsConfig | null | undefined;
+    /** The `crossVenueJourneys` config flag. */
+    readonly enabled: boolean;
+    readonly platform: JourneyPlatform;
+    /** The producer's `mapsProvider` config override; absent leaves it to the platform. */
+    readonly providerOverride?: MapsProvider;
+}
+/**
+ * The outdoor PoI an endpoint IS, when it is one — identity only, because the
+ * endpoint's own `point` is already where the PoI stands, and that is the whole
+ * of a PoI's geometry.
+ *
+ * Carried rather than looked up: a venue is resolvable from a level layer name
+ * and a PoI is not, since an `Outdoor*` layer is never a venue level. A PoI's
+ * identity is the booth's own slug and name, so it has to travel in.
+ *
+ * Whether a booth counts as one is decided at the edge, where the config flags
+ * are (`store/journey-plan.ts`): with `enableExperimentalOutdoorMarkers` off an
+ * `Outdoor*` booth is an ordinary booth and this is absent (ADR-0011). Nothing
+ * in this module reads a flag.
+ */
+export interface JourneyOutdoorPoi {
+    readonly id: string;
+    readonly name: string;
+}
+/**
+ * The route's FROM endpoint as the journey path needs it: which of the three
+ * sources it came from, and the level layer it stands on — the only thing a
+ * venue is looked up by, whether the endpoint is a booth or a bare point.
+ */
+export interface JourneyOriginEndpoint {
+    readonly kind: JourneyOriginKind;
+    readonly layerName: string | undefined;
+    /**
+     * Where the origin stands on the plan — the kiosk's anchor, the visitor's
+     * live position, the from-booth's middle. What the exit door is chosen
+     * against; absent leaves that to the direction of the destination place. Also
+     * where an {@link outdoorPoi} origin stands, which is all such a place is.
+     */
+    readonly point?: Point2Like;
+    /** The outdoor PoI this endpoint is, when it is one. */
+    readonly outdoorPoi?: JourneyOutdoorPoi;
+}
+/**
+ * The route's TO endpoint as the journey path needs it: the level layer that
+ * names its venue, and where it sits on the plan — which is what the arrival
+ * door is chosen against, and where an {@link outdoorPoi} destination stands.
+ */
+export interface JourneyDestinationEndpoint {
+    readonly layerName: string | undefined;
+    /** What the visitor asked for, by name — the booth, not the venue around it. */
+    readonly name?: string;
+    readonly point?: Point2Like;
+    /** The outdoor PoI this endpoint is, when it is one. */
+    readonly outdoorPoi?: JourneyOutdoorPoi;
+}
+/** What one route attempt reveals about graph connectivity. */
+export interface RouteAttempt {
+    readonly hasOrigin: boolean;
+    readonly hasDestination: boolean;
+    /** Whether the engine has routed this very pair, so `routeLineCount` is its answer. */
+    readonly routed: boolean;
+    readonly routeLineCount: number;
+}
+/** Navigator-shaped input for platform detection, so the decision stays testable. */
+export interface PlatformProbe {
+    readonly userAgent: string;
+    readonly platform?: string;
+    readonly maxTouchPoints?: number;
+}
+/**
+ * The graph's connectivity answer for the endpoint pair the app just routed.
+ *
+ * The rendered route *is* the probe: the engine reports "no path" by producing
+ * no route lines, so a fully specified route with none is the graph saying
+ * "unreachable" for exactly this pair. Reading the attempt already made keeps
+ * the answer in step with what the map shows, and costs no second search.
+ *
+ * Null until both endpoints are chosen — there is nothing to be connected yet —
+ * and until the engine has routed the pair: a route is selected before it is
+ * routed, and the lines on hand in between are the previous route's, or none
+ * at all. Read as an answer, "none" is "unreachable", and a journey starts for
+ * a pair the graph connects (#1688).
+ */
+export declare function readGraphConnectivity({ hasOrigin, hasDestination, routed, routeLineCount, }: RouteAttempt): GraphConnectivity | null;
+/**
+ * Apple Maps is the default only where it is the platform's own maps app.
+ * iPadOS reports a desktop-class Mac user agent, so it is told apart the one
+ * way that still works: a Mac that accepts touch.
+ */
+export declare function detectJourneyPlatform({ userAgent, platform, maxTouchPoints, }: PlatformProbe): JourneyPlatform;
+/** The platform of the browser this SDK instance runs in. */
+export declare function currentJourneyPlatform(): JourneyPlatform;
+/**
+ * Adapts the app's venue model and georeference into a planner request, and
+ * returns what the planner decided. The one entry the UI needs; every decision
+ * still belongs to `planJourney`.
+ *
+ * Either end may be a venue or an outdoor PoI (ADR-0011). The venue is tried
+ * first: the two are mutually exclusive by layer — an `Outdoor*` layer is never
+ * a venue level — so the order is defensive rather than load-bearing.
+ */
+export declare function resolveJourneyPlan({ venues, gpsConfig, enabled, platform, providerOverride }: JourneyContext, origin: JourneyOriginEndpoint, destination: JourneyDestinationEndpoint, connectivity: GraphConnectivity): JourneyPlan;
+//# sourceMappingURL=journey-context.d.ts.map