@expofp/floorplan 0.0.0-experimental.2d6c681

package/dist/esm/store/VenueStore.js

@@ -0,0 +1,650 @@
+import { __decorate } from "tslib";
+import { Box } from '@expofp/geometry';
+import { action, computed, observable, runInAction } from 'mobx';
+import loadLayer from '../components/Map/drawing/config/config-load-layer';
+import data from '../data';
+import { extractVenueContourFromLayer } from '../data/svg';
+import { getPlanLayerNames, getReplacingSceneLayerNames } from '../data/venue-scene-preload';
+import { compareIds, parseVenues, } from '../data/venues';
+import debounce from '../tools/debounce';
+import { createFloorActivatedNotifier } from './floor-activated-notifier';
+import { toPublicVenue } from './venue-public';
+/**
+ * What showing a level means: its authored `viewbox` together with the floor
+ * it draws (`rect`), so neither one cuts the other off — an authored viewbox
+ * can stop short of an entrance or courtyard the floor draws. A viewbox
+ * that misses the drawing entirely is not a floor extent (some multi-venue
+ * exports offset it from the artwork) and is left out. Null when the level
+ * carries neither.
+ */
+export function levelFrame(layer) {
+    const { viewbox, rect } = layer;
+    if (!viewbox || !rect)
+        return viewbox ?? rect;
+    return viewbox.intersects(rect) ? Box.fromUnion(viewbox, rect) : rect;
+}
+/**
+ * A venue: a named group of levels within one plan (multi-venue data contract v1,
+ * docs/specs/multi-venue-data-contract.md). Geometry is plan-local; a future
+ * composited-plan source additionally needs a per-venue coordinate transform.
+ */
+export class Venue {
+    constructor(parsed, levels, initialLevel) {
+        this._lastUserActivatedLevelName = observable.box(null);
+        this._presentationState = observable.box(null);
+        this.id = parsed.id;
+        this.name = parsed.name;
+        this.order = parsed.order;
+        this.contour = parsed.contour;
+        this.markerPoint = parsed.markerPoint;
+        this.bounds = parsed.bounds;
+        this.detailMinSizePx = parsed.detailMinSizePx;
+        this.markerMaxSizePx = parsed.markerMaxSizePx;
+        this.auxLayers = parsed.auxLayers.map((ref) => ({ ...ref }));
+        this.levels = levels;
+        this.initialLevel = initialLevel;
+        // The parser guarantees a door stands on a surviving level of this venue;
+        // a level whose plan layer the LayerStore never produced is dropped from
+        // `levels` before it reaches here, and its doors go with it.
+        this.entrances = parsed.entrances.flatMap((entrance) => {
+            const level = levels.find((candidate) => candidate.layer.name === entrance.layer);
+            return level ? [{ level, point: { ...entrance.point }, name: entrance.name }] : [];
+        });
+        this._activeLevelName = observable.box(initialLevel.layer.name);
+    }
+    /** Union of every level's frame — what fitting the whole venue on screen must show. */
+    get frame() {
+        const frames = this.levels
+            .map((level) => levelFrame(level.layer))
+            .filter((box) => !!box);
+        return (frames.length && Box.fromUnion(...frames)) || this.bounds;
+    }
+    /** The single visible level of this venue (venue-scoped Radio). */
+    get activeLevel() {
+        return (this.levels.find((level) => level.layer.name === this._activeLevelName.get()) ??
+            this.initialLevel);
+    }
+    get lastUserActivatedLevel() {
+        const name = this._lastUserActivatedLevelName.get();
+        return name ? (this.levels.find((level) => level.layer.name === name) ?? null) : null;
+    }
+    setActiveLevel(level, userActivated) {
+        this._activeLevelName.set(level.layer.name);
+        if (userActivated)
+            this._lastUserActivatedLevelName.set(level.layer.name);
+    }
+    /**
+     * What this venue shows for the current camera (R5-R9), written by the
+     * camera-tracking hook (`useVenueCameraTracking`). Null until mount-time
+     * evaluation and treated as full detail on plans without the MapLibre map.
+     */
+    get presentationState() {
+        return this._presentationState.get();
+    }
+    set presentationState(state) {
+        this._presentationState.set(state);
+    }
+    /** Full floor detail currently visible (R6); unevaluated counts as visible. */
+    get detailVisible() {
+        return this._presentationState.get()?.detailVisible ?? true;
+    }
+}
+/**
+ * Owns the venue model of a multi-venue plan: the venue list, viewport focus,
+ * and each venue's active level. Levels stay owned by LayerStore; a venue
+ * references them. Populated by `init()` once layers are known; empty (and
+ * therefore inert) on plans without venue data.
+ */
+export default class VenueStore {
+    constructor(rootStore) {
+        this.venues = [];
+        /** Immutable load-time parser and geometry diagnostics. */
+        this.diagnostics = [];
+        /** The plan's authored campus frame (contract §3, Revision 9), when usable. */
+        this.campusViewbox = observable.box(null, {
+            deep: false,
+        });
+        /** Context inferred from the viewport, independent of deliberate intent. */
+        this.automaticContextVenueId = null;
+        /** Deliberate destination context retained until the next manual camera action. */
+        this.destinationVenueId = null;
+        /** Semantic camera request consumed by the MapLibre camera coordinator. */
+        this.cameraRequest = null;
+        /**
+         * Effective context used by the switch and scoped floor API. A destination
+         * override wins over automatic context. Context never changes level visibility.
+         */
+        this.focusedVenueId = null;
+        this.levelActivationRequests = new Map();
+        this.cameraIntentId = 0;
+        this.floorActivatedNotifier = createFloorActivatedNotifier();
+        /** Deferred one tick so `getVenues()` reflects the settled state, as for floors. */
+        this.venueActivatedNotifier = debounce((venue) => this.rootStore.fp.onVenueActivated(toPublicVenue(venue, true)), 0);
+        this.rootStore = rootStore;
+    }
+    get hasVenueModel() {
+        return this.venues.length > 0;
+    }
+    get isCampusMode() {
+        return this.hasVenueModel && !!this.rootStore?.maplibreStore.showMaplibre;
+    }
+    /** Venue-switch order: resolved `order`, then `id` — never array position (§9). */
+    get orderedVenues() {
+        return [...this.venues].sort((a, b) => a.order - b.order || compareIds(a.id, b.id));
+    }
+    get focusedVenue() {
+        return this.venues.find((v) => v.id === this.focusedVenueId) ?? null;
+    }
+    /** First venue by resolved order. */
+    get defaultVenue() {
+        return this.orderedVenues[0] ?? null;
+    }
+    /**
+     * The whole-campus frame: the plan's authored campus viewbox, otherwise the
+     * union of every venue footprint. The initial fit, `viewAllVenues()` and a
+     * no-context Fit-to-screen all read it, so a plan opens on exactly the rect
+     * "View all venues" returns to. Null on plans without a venue model.
+     */
+    get campusBounds() {
+        if (!this.venues.length)
+            return null;
+        return (this.campusViewbox.get() ??
+            (Box.fromUnion(...this.venues.map((venue) => venue.bounds)) || null));
+    }
+    /**
+     * Whether `campusBounds` is the authored campus viewbox. An authored frame is
+     * shown as-is, with no fit padding beyond the chrome; the footprint union is
+     * bare geometry and keeps its breathing room. Every campus fit decides its
+     * padding from this one flag, so they all land on the same camera.
+     */
+    get campusBoundsAuthored() {
+        return this.hasVenueModel && this.campusViewbox.get() !== null;
+    }
+    /** The context venue when available, otherwise the resolved non-MapLibre default. */
+    get fallbackVenue() {
+        return this.focusedVenue ?? this.defaultVenue;
+    }
+    /** Public active venue: nullable campus context, or the resolved fallback venue. */
+    get activeVenue() {
+        return this.isCampusMode ? this.focusedVenue : this.fallbackVenue;
+    }
+    /**
+     * Aux-referenced plan layers by name → referencing venues (usually one).
+     * These layers must never behave as floors: LayerStore excludes them from
+     * `venueLayers`/`floors`, and their scene visibility is owned exclusively
+     * by the zoom sync (`useLayerVisibilitySync`, KTD-1/KTD-2).
+     */
+    get auxVenuesByLayerName() {
+        const byName = new Map();
+        for (const venue of this.venues) {
+            for (const ref of venue.auxLayers) {
+                const owners = byName.get(ref.layer);
+                if (!owners)
+                    byName.set(ref.layer, [venue]);
+                else if (!owners.includes(venue))
+                    owners.push(venue);
+            }
+        }
+        return byName;
+    }
+    /**
+     * What the selector renders (KTD-5, Google Maps pattern): the focused
+     * venue's level list only while that venue shows floor detail; the venue
+     * list otherwise - in a no-context campus view, and while the focused venue
+     * has degraded below its detail cutoff (no floors to pick from at that zoom).
+     */
+    get selectorMode() {
+        return this.focusedVenue?.detailVisible ? 'levels' : 'venues';
+    }
+    /**
+     * Level layer name → owning venue. The parser guarantees a layer belongs to
+     * at most one venue, so this is a plain map rather than a multimap.
+     */
+    get venuesByLevelLayerName() {
+        const byName = new Map();
+        for (const venue of this.venues) {
+            for (const level of venue.levels)
+                byName.set(level.layer.name, venue);
+        }
+        return byName;
+    }
+    venueOfLayer(layerOrName) {
+        const name = typeof layerOrName === 'string' ? layerOrName : layerOrName?.name;
+        if (!name)
+            return null;
+        return this.venuesByLevelLayerName.get(name) ?? null;
+    }
+    /**
+     * Resolves a venue by `id` and only by `id` (contract §9): `name` is display
+     * text an organizer may localize or retype at any time, so matching it would
+     * make the fragile handle the addressable one. Only the argument is
+     * normalized — a parsed venue's `id` already matches `[a-z0-9_-]+` — so an
+     * uppercased deep link still resolves.
+     */
+    findVenue(id) {
+        const normalizedId = id.toLowerCase();
+        return this.venues.find((venue) => venue.id === normalizedId) ?? null;
+    }
+    /**
+     * The venue whose building outline holds a plan point — the smallest one
+     * when outlines nest. Null outdoors and on plans without a venue model.
+     */
+    venueAt(point) {
+        let found = null;
+        for (const venue of this.venues) {
+            if (!venue.bounds.containsPoint(point) || !ringContainsPoint(venue.contour, point))
+                continue;
+            if (!found || venue.bounds.area < found.bounds.area)
+                found = venue;
+        }
+        return found;
+    }
+    /**
+     * Builds the venue model from `data.venues` once LayerStore holds the plan's
+     * layers (called from init-layers). Malformed data yields no venues and the
+     * plan behaves exactly as today.
+     */
+    init() {
+        const layerStore = this.rootStore.layerStore;
+        const layerByName = new Map(layerStore.layers.filter((l) => l && !l.rootParent).map((l) => [l.name, l]));
+        const geometry = new Map(Array.from(layerByName, ([name, layer]) => [
+            name,
+            { rect: layer.rect, viewbox: layer.viewbox },
+        ]));
+        const rawVenues = typeof data === 'object' &&
+            data !== null &&
+            (data.venuesVersion === undefined || data.venuesVersion === 1) &&
+            Array.isArray(data.venues)
+            ? data.venues
+            : [];
+        const planLayerNames = getPlanLayerNames();
+        const sceneCandidates = rawVenues.map((rawVenue) => {
+            const names = new Set(getReplacingSceneLayerNames(rawVenue));
+            return planLayerNames
+                .filter((name) => names.has(name))
+                .map((name) => {
+                try {
+                    return {
+                        layer: name,
+                        extraction: extractVenueContourFromLayer(name),
+                    };
+                }
+                catch {
+                    return { layer: name, extraction: { ring: null, unusableElementKinds: [] } };
+                }
+            });
+        });
+        const result = parseVenues(data, geometry, sceneCandidates);
+        const parsed = result.venues;
+        this.diagnostics = result.diagnostics;
+        this.campusViewbox.set(result.campusViewbox);
+        layerStore.setQuarantinedLayerNames(result.quarantinedLayerNames);
+        this.venues = parsed.map((p) => {
+            const levels = p.levels.flatMap((parsedLevel) => {
+                const layer = layerByName.get(parsedLevel.layer);
+                return layer
+                    ? [
+                        {
+                            layer,
+                            ordinal: parsedLevel.ordinal,
+                            displayName: parsedLevel.name ?? layer.description,
+                            initial: parsedLevel.initial,
+                        },
+                    ]
+                    : [];
+            });
+            const initial = levels.find((level) => level.initial) ?? levels[0];
+            return new Venue(p, levels, initial);
+        });
+        this.automaticContextVenueId = null;
+        this.destinationVenueId = null;
+        this.focusedVenueId = null;
+        this.cameraRequest = null;
+        this.levelActivationRequests.clear();
+        this.cameraIntentId++;
+        if (this.isCampusMode)
+            this.applyInitialVisibility();
+        else if (this.hasVenueModel)
+            this.applyFallbackVisibility();
+    }
+    /**
+     * Venue-scoped visibility baseline: every venue shows exactly its active
+     * level; non-venue layers (pathways, frozen/technical) are untouched.
+     * Idempotent — also re-applied when the MapLibre map becomes ready.
+     */
+    applyInitialVisibility() {
+        if (!this.isCampusMode)
+            return;
+        for (const venue of this.venues) {
+            // Reset presentation to unevaluated: after a map remount the scene
+            // defs are rebuilt from visibility alone, so an unchanged state would
+            // never re-fire the def-sync reaction and stale floor detail would
+            // render beneath the degraded visuals. The mount-time camera evaluation
+            // then writes a fresh state the sync can react to.
+            venue.presentationState = null;
+            for (const level of venue.levels) {
+                this.rootStore.layerStore.setLayerVisibility(level.layer, level === venue.activeLevel);
+            }
+        }
+    }
+    /**
+     * R14 fallback for venue plans without the MapLibre map (legacy 2D renderer):
+     * the plan degrades to a single-venue-like multi-floor plan — only the
+     * focused (or default) venue's active level stays visible.
+     */
+    applyFallbackVisibility() {
+        if (!this.hasVenueModel)
+            return;
+        const fallback = this.fallbackVenue;
+        for (const venue of this.venues) {
+            for (const level of venue.levels) {
+                this.rootStore.layerStore.setLayerVisibility(level.layer, venue === fallback && level === venue.activeLevel);
+            }
+        }
+    }
+    /** Updates viewport-inferred context without disturbing a destination override. */
+    setAutomaticContext(venueOrId) {
+        const venue = venueOrId === null
+            ? null
+            : typeof venueOrId === 'string'
+                ? (this.venues.find((candidate) => candidate.id === venueOrId) ?? null)
+                : venueOrId;
+        this.automaticContextVenueId = venue?.id ?? null;
+        if (this.destinationVenueId === null)
+            this.setEffectiveContext(venue);
+    }
+    /** Establishes deliberate destination context and optionally moves the camera. */
+    enterVenue(venueOrId, { fly = true, level: levelOrName } = {}) {
+        const venue = typeof venueOrId === 'string' ? this.venues.find((v) => v.id === venueOrId) : venueOrId;
+        if (!venue)
+            return Promise.resolve();
+        const outgoingVenue = this.activeVenue;
+        const cameraIntentId = ++this.cameraIntentId;
+        this.cameraRequest = null;
+        this.destinationVenueId = venue.id;
+        this.setEffectiveContext(venue);
+        const explicitLevel = this.resolveVenueLevel(venue, levelOrName);
+        const level = explicitLevel ??
+            venue.levels.find((candidate) => candidate.ordinal === outgoingVenue?.activeLevel.ordinal) ??
+            venue.lastUserActivatedLevel ??
+            venue.initialLevel;
+        const activation = this.activateLayer(level.layer, {
+            fly: !!explicitLevel && fly,
+            establishDestination: false,
+            cameraIntentId,
+            userActivated: !!explicitLevel,
+        });
+        if (explicitLevel || !fly)
+            return activation;
+        this.requestVenueCamera(venue, level, cameraIntentId);
+        return activation;
+    }
+    /** Backward-compatible name for deliberate venue entry. */
+    focusVenue(venueOrId, options = {}) {
+        return this.enterVenue(venueOrId, options);
+    }
+    /** Releases deliberate intent; viewport-inferred context becomes effective immediately. */
+    releaseDestinationOverride() {
+        if (this.destinationVenueId === null)
+            return;
+        this.destinationVenueId = null;
+        const automatic = this.venues.find((venue) => venue.id === this.automaticContextVenueId) ?? null;
+        this.setEffectiveContext(automatic);
+    }
+    /** Clears a consumed request without discarding a newer superseding request. */
+    clearCameraRequest(request) {
+        if (this.cameraRequest === request)
+            this.cameraRequest = null;
+    }
+    /** Requests a useful whole-campus fit while retaining context until settle. */
+    viewAllVenues() {
+        const rect = this.campusBounds;
+        if (!rect)
+            return;
+        const intentId = ++this.cameraIntentId;
+        if (this.rootStore.maplibreStore.showMaplibre) {
+            this.cameraRequest = { kind: 'campus', intentId, rect };
+        }
+        else {
+            this.rootStore.uiState.moveToRect = rect;
+            this.completeCampusView();
+        }
+    }
+    /**
+     * Re-frames the active venue on its active level — what Fit-to-screen does
+     * while a venue is in context, instead of pulling back to the whole plan.
+     * Returns false when no venue is active (a campus view with no context, or a
+     * plan without a venue model), leaving the plan-wide fit to the caller.
+     */
+    frameActiveVenue() {
+        const venue = this.activeVenue;
+        if (!venue)
+            return false;
+        this.requestVenueCamera(venue, venue.activeLevel);
+        return true;
+    }
+    /** Called when the campus camera movement settles; normal spatial context resumes. */
+    completeCampusView(request) {
+        if (request && (request.kind !== 'campus' || request.intentId !== this.cameraIntentId)) {
+            return;
+        }
+        this.releaseDestinationOverride();
+    }
+    /** No-context state: no venue has sufficient spatial confidence. */
+    clearFocus() {
+        this.automaticContextVenueId = null;
+        this.destinationVenueId = null;
+        this.setEffectiveContext(null);
+    }
+    /**
+     * Activates a level: venue-scoped Radio (only this venue's levels toggle),
+     * focus follows to the level's venue, the camera flies to the level, and
+     * `onFloorActivated` fires — the multi-venue counterpart of today's floor
+     * activation. No-op for layers outside any venue. `fly: false` keeps the
+     * camera untouched — the selection path uses it because the booth camera
+     * reaction owns that fly (KTD-7/KTD-8).
+     */
+    activateLayer(layer, { fly = true, establishDestination = true, cameraIntentId, userActivated = true, } = {}) {
+        const venue = this.venueOfLayer(layer);
+        if (!venue)
+            return Promise.resolve();
+        if (establishDestination)
+            return this.enterVenue(venue, { fly, level: layer });
+        const venueLevel = venue.levels.find((level) => level.layer === layer);
+        if (!venueLevel)
+            return Promise.resolve();
+        const activationRequest = this.nextLevelActivationRequest(venue.id);
+        const activationCameraIntentId = cameraIntentId ?? this.cameraIntentId;
+        if (this.rootStore.routeStore.currentRouteLayer !== layer) {
+            this.rootStore.routeStore.currentRouteLayer = layer;
+        }
+        if (venue.activeLevel === venueLevel && layer.visible) {
+            venue.setActiveLevel(venueLevel, userActivated);
+            if (fly)
+                this.requestVenueCamera(venue, venueLevel);
+            return Promise.resolve();
+        }
+        return loadLayer(layer).then(() => {
+            runInAction(() => {
+                if (activationRequest !== this.levelActivationRequests.get(venue.id))
+                    return;
+                for (const level of venue.levels) {
+                    if (level !== venueLevel && level.layer.visible) {
+                        this.rootStore.layerStore.setLayerVisibility(level.layer, false);
+                    }
+                }
+                this.rootStore.layerStore.setLayerVisibility(layer, true);
+                venue.setActiveLevel(venueLevel, userActivated);
+                if (fly &&
+                    this.destinationVenueId === venue.id &&
+                    activationCameraIntentId === this.cameraIntentId) {
+                    this.requestVenueCamera(venue, venueLevel, activationCameraIntentId);
+                }
+                if (this.destinationVenueId === venue.id)
+                    this.notifyFloorActivated(layer);
+            });
+        });
+    }
+    notifyVenueActivated(venue) {
+        if (typeof this.rootStore.fp?.onVenueActivated !== 'function')
+            return;
+        this.venueActivatedNotifier(venue);
+    }
+    setEffectiveContext(venue) {
+        const changed = this.focusedVenueId !== venue?.id;
+        this.focusedVenueId = venue?.id ?? null;
+        if (!changed)
+            return;
+        // Without MapLibre only the effective venue's active level renders.
+        if (!this.rootStore.maplibreStore.showMaplibre)
+            this.applyFallbackVisibility();
+        if (!venue)
+            return;
+        this.notifyVenueActivated(venue);
+    }
+    /**
+     * Frames a venue on one of its levels. By default the level's frame (see
+     * {@link levelFrame}) is the target, as on a single-venue plan's floor
+     * switch. `enableExperimentalVenueFraming` instead holds the venue footprint
+     * across levels — a venue's levels are one building.
+     */
+    requestVenueCamera(venue, level, intentId = this.cameraIntentId) {
+        const rect = data.enableExperimentalVenueFraming === true
+            ? venue.bounds
+            : (levelFrame(level.layer) ?? venue.bounds);
+        if (!this.rootStore.maplibreStore.showMaplibre) {
+            this.rootStore.uiState.moveToRect = rect;
+            return;
+        }
+        this.cameraRequest = {
+            kind: 'venue',
+            intentId,
+            venueId: venue.id,
+            layer: level.layer.name,
+            rect,
+        };
+    }
+    nextLevelActivationRequest(venueId) {
+        const request = (this.levelActivationRequests.get(venueId) ?? 0) + 1;
+        this.levelActivationRequests.set(venueId, request);
+        return request;
+    }
+    resolveVenueLevel(venue, levelOrName) {
+        if (typeof levelOrName === 'string') {
+            return venue.levels.find((level) => level.layer.name === levelOrName);
+        }
+        if (!levelOrName)
+            return undefined;
+        return venue.levels.find((level) => level === levelOrName || level.layer === levelOrName);
+    }
+    notifyFloorActivated(layer) {
+        this.floorActivatedNotifier(this.rootStore.fp, layer.name);
+    }
+}
+__decorate([
+    observable
+], VenueStore.prototype, "venues", void 0);
+__decorate([
+    observable
+], VenueStore.prototype, "diagnostics", void 0);
+__decorate([
+    observable
+], VenueStore.prototype, "automaticContextVenueId", void 0);
+__decorate([
+    observable
+], VenueStore.prototype, "destinationVenueId", void 0);
+__decorate([
+    observable
+], VenueStore.prototype, "cameraRequest", void 0);
+__decorate([
+    observable
+], VenueStore.prototype, "focusedVenueId", void 0);
+__decorate([
+    computed({ keepAlive: true })
+], VenueStore.prototype, "hasVenueModel", null);
+__decorate([
+    computed({ keepAlive: true })
+], VenueStore.prototype, "isCampusMode", null);
+__decorate([
+    computed({ keepAlive: true })
+], VenueStore.prototype, "orderedVenues", null);
+__decorate([
+    computed({ keepAlive: true })
+], VenueStore.prototype, "focusedVenue", null);
+__decorate([
+    computed({ keepAlive: true })
+], VenueStore.prototype, "defaultVenue", null);
+__decorate([
+    computed({ keepAlive: true })
+], VenueStore.prototype, "campusBounds", null);
+__decorate([
+    computed({ keepAlive: true })
+], VenueStore.prototype, "campusBoundsAuthored", null);
+__decorate([
+    computed({ keepAlive: true })
+], VenueStore.prototype, "fallbackVenue", null);
+__decorate([
+    computed({ keepAlive: true })
+], VenueStore.prototype, "activeVenue", null);
+__decorate([
+    computed({ keepAlive: true })
+], VenueStore.prototype, "auxVenuesByLayerName", null);
+__decorate([
+    computed({ keepAlive: true })
+], VenueStore.prototype, "selectorMode", null);
+__decorate([
+    computed({ keepAlive: true })
+], VenueStore.prototype, "venuesByLevelLayerName", null);
+__decorate([
+    action
+], VenueStore.prototype, "init", null);
+__decorate([
+    action
+], VenueStore.prototype, "applyInitialVisibility", null);
+__decorate([
+    action
+], VenueStore.prototype, "applyFallbackVisibility", null);
+__decorate([
+    action
+], VenueStore.prototype, "setAutomaticContext", null);
+__decorate([
+    action
+], VenueStore.prototype, "enterVenue", null);
+__decorate([
+    action
+], VenueStore.prototype, "focusVenue", null);
+__decorate([
+    action
+], VenueStore.prototype, "releaseDestinationOverride", null);
+__decorate([
+    action
+], VenueStore.prototype, "clearCameraRequest", null);
+__decorate([
+    action
+], VenueStore.prototype, "viewAllVenues", null);
+__decorate([
+    action
+], VenueStore.prototype, "frameActiveVenue", null);
+__decorate([
+    action
+], VenueStore.prototype, "completeCampusView", null);
+__decorate([
+    action
+], VenueStore.prototype, "clearFocus", null);
+__decorate([
+    action
+], VenueStore.prototype, "activateLayer", null);
+/** Even-odd containment of a plan point in a closed ring; outlines may be concave. */
+function ringContainsPoint(ring, point) {
+    let inside = false;
+    for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {
+        const a = ring[i];
+        const b = ring[j];
+        if (a.y > point.y !== b.y > point.y) {
+            const crossX = a.x + ((point.y - a.y) * (b.x - a.x)) / (b.y - a.y);
+            if (point.x < crossX)
+                inside = !inside;
+        }
+    }
+    return inside;
+}

package/dist/esm/store/create-live-plan.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Builds the store graph belonging to the plan being loaded and points the
+ * barrel at it.
+ *
+ * The one construction site: there is no module-scope `new RootStore()` any
+ * more, so a first load and every later swap run this exact path (ADR-0011).
+ * The load path must call it strictly *after* `setConfig()` — the stores and
+ * `init()` read the event data as they are built, and against the previous
+ * event's config they would rebuild the fresh/stale hybrid the plan swap
+ * exists to kill.
+ */
+export declare function createLivePlan(): void;
+//# sourceMappingURL=create-live-plan.d.ts.map

package/dist/esm/store/create-live-plan.js

@@ -0,0 +1,25 @@
+import { registerPlanDisposer } from '../plan-lifecycle.js';
+import init from './init/index.js';
+import { setLiveStore, store } from './live-store.js';
+import RootStore from './RootStore.js';
+/**
+ * Builds the store graph belonging to the plan being loaded and points the
+ * barrel at it.
+ *
+ * The one construction site: there is no module-scope `new RootStore()` any
+ * more, so a first load and every later swap run this exact path (ADR-0011).
+ * The load path must call it strictly *after* `setConfig()` — the stores and
+ * `init()` read the event data as they are built, and against the previous
+ * event's config they would rebuild the fresh/stale hybrid the plan swap
+ * exists to kill.
+ */
+export function createLivePlan() {
+    const instance = new RootStore();
+    // Registered before anything else, so it is disposed last: the reactions and
+    // listeners torn down above it still read the barrel while they unwind.
+    setLiveStore(instance);
+    registerPlanDisposer(() => setLiveStore(null));
+    init(instance);
+    // Debug handle; `resetGlobalVariables()` drops it on destroy.
+    window.__store = store;
+}