@expofp/config 3.11.10

package/dist/lib/legacy-url.js

@@ -0,0 +1,322 @@
+/**
+ * Legacy URL grammar — the compact deep-link language the floor plan has always
+ * spoken (`?<slug>`, `?route:B-12:A-3:false`, `?tour=t1`, `?planner=a:b&from=c`,
+ * one-shot params like `?blue-dot=…` or `?viewermode=1`), as one pure codec:
+ *
+ *   parseLegacyQuery(search)       raw `location.search` → typed commands
+ *   serializeSelection(selection)  selection descriptor  → `location.search`
+ *
+ * Both halves speak the SAME grammar, so shortcuts stay bidirectional: the slug
+ * a shared link carries is the slug the plan writes back when the visitor picks
+ * an entity (round-trip covered by tests). The floor plan maps commands to its
+ * public methods / stores and its UI state to a selection descriptor — nothing
+ * here touches a store or the DOM.
+ *
+ * Encoding contract (inherited from the legacy router, byte-compatible):
+ * the WHOLE query payload is one `encodeURIComponent` unit — `route:a:b`
+ * travels as `?route%3Aa%3Ab`, `planner&source=bookmarks` as
+ * `?planner%26source%3Dbookmarks` — and the parser decodes the whole string
+ * before splitting. Keys owned by the config layer (`UrlConfigSchema`) and
+ * intent-shortcut keys (`IntentsSchema` arm names) are consumed by `loadConfig`
+ * at boot, so the parser strips them from the residual slug here — one place
+ * knows the full key partition of the query.
+ *
+ * LEGACY GRAMMAR — frozen. Do not add keys or forms here. New URL capabilities
+ * are born in `UrlConfigSchema` (config keys) or `IntentsSchema` (intent arms)
+ * — see docs/evgeny-thoughts/2026-07-09-legacy-url-retirement.md §2. The parse
+ * side stays alive for links already shared in the wild, but only as a
+ * translator into those two channels; the sole legitimate consumer is
+ * `packages/floorplan/src/services/url-dispatch.ts` (lint-enforced).
+ */
+import { IntentsSchema, UrlConfigSchema } from '@expofp/schema';
+import { safeDecode } from '@expofp/utils';
+/* ── Parse: location.search → commands ─────────────────────────────────────── */
+/** Query keys consumed by `loadConfig` before dispatch: config slice + intent shortcuts. */
+const configOwnedKeys = new Set([
+    ...Object.keys(UrlConfigSchema.shape),
+    ...IntentsSchema.options.map((arm) => arm.shape.name.value),
+]);
+/** One-shot keys the parser consumes into commands (never part of the slug). */
+const oneShotKeys = new Set(['blue-dot', 'viewermode', 'previewMode', 'uiscale', 'resetuiscale']);
+/**
+ * The legacy camera params, translated into `config.camera`'s shape. Stripped
+ * from the slug only in their `key=value` form — a bare slug that merely spells
+ * one of these words (a booth named "center") still resolves via the catalog.
+ */
+const legacyCameraKeys = new Set(['centerxy', 'center', 'z', 'bearing', 'zoomtime', 'roll']);
+export function parseLegacyQuery(search) {
+    const rawQuery = search.startsWith('?') ? search.slice(1) : search;
+    // the legacy contract: the payload is one encodeURIComponent unit
+    const decoded = safeDecode(rawQuery);
+    const params = new URLSearchParams(decoded);
+    const oneShots = collectOneShots(rawQuery, params);
+    // `?preview=`, `?b=`/`?ba=` (leading param) and `?copy_exh` historically
+    // wiped the whole query before the other one-shots could see it — only the
+    // heatmap flags (processed first) and the bookmark redirect itself survive
+    const wiped = rawQuery.startsWith('preview=') ||
+        rawQuery.startsWith('b=') ||
+        rawQuery.startsWith('ba=') ||
+        decoded.includes('copy_exh');
+    if (wiped) {
+        return {
+            primary: { type: 'select', slug: '' },
+            oneShots: oneShots.filter((s) => s.type === 'heatmap' || s.type === 'legacyBookmarks'),
+        };
+    }
+    return {
+        primary: classifyPrimary(residualSlug(decoded), params, hasConfigOwnedParts(decoded)),
+        oneShots,
+    };
+}
+function classifyPrimary(slug, params, configOwned) {
+    if (params.has('kiosk')) {
+        const value = params.get('kiosk');
+        return { type: 'kiosk', enabled: value === '1' ? true : value === '0' ? false : null };
+    }
+    if (slug === 'tours')
+        return { type: 'list', list: 'tours' };
+    if (slug.startsWith('tour='))
+        return { type: 'tour', tourId: slug.split('=')[1] };
+    if (params.has('planner')) {
+        return {
+            type: 'planner',
+            fromBookmarks: params.get('source') === 'bookmarks',
+            items: (params.get('planner') ?? '').split(':').filter(Boolean),
+            from: params.get('from') ?? undefined,
+        };
+    }
+    if (slug.startsWith('route')) {
+        const parts = slug.split(':');
+        return {
+            type: 'route',
+            to: parts[1],
+            from: parts[2],
+            accessible: parts[3] === 'true',
+            waypoints: parts.slice(4),
+            title: params.get('title') ?? undefined,
+        };
+    }
+    if (slug === 'bookmarks')
+        return { type: 'list', list: 'bookmarks' };
+    if (slug === 'visited')
+        return { type: 'list', list: 'visited' };
+    if (slug === 'language')
+        return { type: 'list', list: 'language' };
+    if (params.has('lang')) {
+        return { type: 'language', langId: params.get('lang')?.toLowerCase() };
+    }
+    if (slug === 'sessions')
+        return { type: 'list', list: 'sessions' };
+    if (slug === 'exhibitors')
+        return { type: 'list', list: 'exhibitors' };
+    if (slug === 'speakers')
+        return { type: 'list', list: 'speakers' };
+    if (slug === '-pdf')
+        return { type: 'printPdf' };
+    if (slug.startsWith('hide')) {
+        const hidden = (new URLSearchParams(slug).get('hide') ?? '').split(',').filter(Boolean);
+        return { type: 'visibility', hidden };
+    }
+    if (slug === 'build-route')
+        return { type: 'buildRoute' };
+    const pathwayId = params.get('pathway');
+    if (pathwayId) {
+        return {
+            type: 'pathway',
+            pathwayId,
+            boothIds: params.get('booths')?.split(',') ?? [],
+            exhibitorIds: params.get('exhibitors')?.split(',') ?? [],
+            tourId: params.get('tour') ?? undefined,
+        };
+    }
+    if (slug.startsWith('exhibitors') && slug.includes('=')) {
+        return { type: 'selectExhibitors', values: slug.split('=')[1].split(',') };
+    }
+    if (slug.includes('=') && (slug.startsWith('categories=') || /^poiTypes?=/.test(slug))) {
+        return { type: 'ownedByFilters' };
+    }
+    // Last, after every params-based branch above (`?kiosk=1&camera[x]=5` is
+    // still the kiosk toggle): an empty slug that got empty because config/
+    // intent keys owned the whole query is NOT the "clear the selection"
+    // command a genuinely empty query is — replaying it as `select('')` would
+    // close whatever is open.
+    if (!slug && configOwned) {
+        return { type: 'ownedByConfig' };
+    }
+    return { type: 'select', slug };
+}
+function collectOneShots(rawQuery, params) {
+    const oneShots = [];
+    if (params.get('heatmap') === 'true') {
+        oneShots.push({
+            type: 'heatmap',
+            yah: params.get('type') === 'yah',
+            kiosk: params.get('subtype') === 'kiosk',
+        });
+    }
+    if (rawQuery.startsWith('b=') || rawQuery.startsWith('ba=')) {
+        const appendRaw = new URLSearchParams(rawQuery).get('ba');
+        const appendExhibitorId = appendRaw === null ? null : parseInt(appendRaw, 10);
+        oneShots.push({
+            type: 'legacyBookmarks',
+            appendExhibitorId: Number.isFinite(appendExhibitorId) ? appendExhibitorId : null,
+        });
+    }
+    const blueDot = params.get('blue-dot');
+    if (blueDot !== null) {
+        const p = blueDot.split(',');
+        const x = Number(p[0]);
+        const y = Number(p[1]);
+        if (p.length > 1 && Number.isFinite(x) && Number.isFinite(y)) {
+            oneShots.push({
+                type: 'blueDot',
+                x,
+                y,
+                layer: p[2],
+                lat: Number(p[3]) || undefined,
+                lng: Number(p[4]) || undefined,
+            });
+        }
+    }
+    const viewerMode = params.get('viewermode');
+    if (viewerMode === '1' || viewerMode === 'true') {
+        oneShots.push({ type: 'viewerMode', enabled: true });
+    }
+    else if (viewerMode === '0' || viewerMode === 'false') {
+        oneShots.push({ type: 'viewerMode', enabled: false });
+    }
+    const previewMode = params.get('previewMode');
+    if (previewMode === 'true') {
+        oneShots.push({ type: 'previewMode', enabled: true });
+    }
+    else if (previewMode === 'false') {
+        oneShots.push({ type: 'previewMode', enabled: false });
+    }
+    if (params.has('resetuiscale')) {
+        oneShots.push({ type: 'resetUiScale' });
+    }
+    const uiScaleRaw = params.get('uiscale');
+    if (uiScaleRaw) {
+        const scale = parseFloat(uiScaleRaw.replace(',', '.'));
+        const valid = !Number.isNaN(scale) && scale >= 0.8 && scale <= 1.4;
+        oneShots.push({ type: 'uiScale', scale: valid ? scale : null, raw: uiScaleRaw });
+    }
+    const camera = legacyCamera(params);
+    if (camera) {
+        oneShots.push(camera);
+    }
+    return oneShots;
+}
+/** Translate the legacy camera params into the schema-typed `Camera` shape. */
+function legacyCamera(params) {
+    const camera = {};
+    const centerxy = numberPair(params.get('centerxy'));
+    if (centerxy)
+        [camera.x, camera.y] = centerxy;
+    const center = numberPair(params.get('center'));
+    if (center)
+        [camera.lat, camera.lng] = center;
+    const floor = params.get('z');
+    if (floor)
+        camera.floor = floor;
+    const bearing = finiteNumber(params.get('bearing'));
+    if (bearing !== undefined)
+        camera.bearing = bearing;
+    const zoomTime = finiteNumber(params.get('zoomtime'));
+    if (zoomTime !== undefined)
+        camera.zoomTime = zoomTime;
+    const roll = finiteNumber(params.get('roll'));
+    if (!Object.keys(camera).length && roll === undefined)
+        return null;
+    return roll === undefined ? { type: 'camera', camera } : { type: 'camera', camera, roll };
+}
+function numberPair(value) {
+    if (!value)
+        return undefined;
+    const parts = value.split(',').map(parseFloat);
+    if (parts.length !== 2 || !parts.every(Number.isFinite))
+        return undefined;
+    return [parts[0], parts[1]];
+}
+function finiteNumber(value) {
+    if (value === null || value === '')
+        return undefined;
+    const parsed = parseFloat(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+/**
+ * The slug is the decoded query minus every key another consumer owns: the
+ * config layer's keys and intent shortcuts (read by `loadConfig`), and the
+ * one-shot keys consumed above. `heatmap`/`type`/`subtype` stay in the slug —
+ * heatmap mode historically froze the URL with them in place (its data loader
+ * re-reads them), and the select fallback knows not to treat a query carrying
+ * `heatmap=true` as search text.
+ */
+function hasConfigOwnedParts(decoded) {
+    return decoded.split('&').some((part) => {
+        const rawKey = part.split('=')[0];
+        // the legacy scalar `?heatmap=true` is slug-resident (see residualSlug)
+        if (rawKey === 'heatmap')
+            return false;
+        return configOwnedKeys.has(rawKey.split('[')[0]);
+    });
+}
+function residualSlug(decoded) {
+    return decoded
+        .split('&')
+        .filter((part) => {
+        if (!part)
+            return false;
+        const key = part.split('=')[0].split('[')[0];
+        if (legacyCameraKeys.has(key) && part.includes('='))
+            return false;
+        // Carve-out (retirement plan §4.8): `heatmap` is a UrlConfigSchema key
+        // now, so the canonical bracketed `heatmap[…]=` form is config-owned and
+        // strips like any other — but the legacy scalar `?heatmap=true` must
+        // KEEP the slug residency described above (the select fallback
+        // recognizes the literal `heatmap=true`; the frozen URL carries it for
+        // the data loader). Discriminate on the raw key: no bracket ⇒ legacy.
+        if (part.split('=')[0] === 'heatmap')
+            return true;
+        return !configOwnedKeys.has(key) && !oneShotKeys.has(key);
+    })
+        .join('&');
+}
+/* ── Serialize: selection → location.search ────────────────────────────────── */
+/**
+ * The selection's canonical query — `''` for none, else `?<payload>` with the
+ * whole payload as one `encodeURIComponent` unit (the legacy contract). This is
+ * the string the single URL writer puts in the address bar, byte-compatible
+ * with the URLs the legacy router wrote (shared links keep working).
+ */
+export function serializeSelection(selection) {
+    const queryRaw = selectionPayload(selection);
+    return queryRaw ? '?' + encodeURIComponent(queryRaw) : '';
+}
+function selectionPayload(selection) {
+    switch (selection.type) {
+        case 'none':
+            return '';
+        case 'slug':
+            return selection.slug;
+        case 'route': {
+            const to = selection.to ? `:${selection.to}` : '';
+            const from = selection.from ? `:${selection.from}` : '';
+            const accessible = selection.accessible ? ':true' : ':false';
+            const waypoints = (selection.waypoints ?? []).map((w) => `:${w}`).join('');
+            return `route${to}${from}${accessible}${waypoints}`;
+        }
+        case 'planner': {
+            const base = selection.fromBookmarks
+                ? 'planner&source=bookmarks'
+                : `planner=${(selection.items ?? []).join(':')}`;
+            return selection.from ? `${base}&from=${selection.from}` : base;
+        }
+        case 'list':
+            return selection.list;
+        case 'tour':
+            return `tour=${selection.tourId}`;
+        case 'filter':
+            return `${selection.key}=${selection.value}`;
+    }
+}

package/dist/lib/load-config.d.ts

@@ -0,0 +1,26 @@
+import { type Ref } from '@expofp/resolve';
+import { type Config, type Manifest, type Options } from '@expofp/schema';
+import { type StorageLike } from './local-storage-codec.js';
+/**
+ * Assemble the effective config — the runtime's single, complete copy of the
+ * expo data — by layering, lowest to highest precedence:
+ * manifest (+ its legacy data.js) → options → localStorage → URL.
+ *
+ * With a `legacyDataUrlBase` (live events), the version probe settles the
+ * `?v=` cache-buster, refs to the sibling drawing / wayfinding files are
+ * derived from it (`data.js` never carries them), and all three legacy files —
+ * `data.js` evaluated to its `__data` document like every legacy `.js` file,
+ * asset-resolved and merged in — are fetched in parallel. A manifest can
+ * instead carry the merged data itself plus explicit refs (offline copies) —
+ * then nothing is derived. The config holds only the REFS; the payloads live
+ * in `@expofp/resolve`'s memo: `loadConfig` resolves `fpSvgJsRef` and
+ * `wfDataJsRef` before returning, so consumers read them synchronously with
+ * `getResolved` from then on. Legacy normalization and the rebooking merge
+ * run last, and the result is deep-frozen.
+ *
+ * `url` / `storage` are browser inputs (page query, `localStorage`); Node
+ * callers (the offline CLI) omit them, which also skips those layers and the
+ * rebooking token lookup.
+ */
+export declare function loadConfig(manifest: Manifest | Ref<Manifest>, options: Options, url?: string, storage?: StorageLike): Promise<Config>;
+//# sourceMappingURL=load-config.d.ts.map

package/dist/lib/load-config.js

@@ -0,0 +1,286 @@
+/// <reference lib="dom" />
+import { resolve } from '@expofp/resolve';
+import { ConfigDefaults, DataJsSchema, FpSvgJsSchema, FpSvgLayerJsSchema, LocalStorageConfigSchema, ManifestSchema, OptionsSchema, UrlConfigSchema, WfDataJsSchema, } from '@expofp/schema';
+import { deepClone, deepFreeze } from '@expofp/utils';
+import debug from 'debug';
+import { parseFromStorage } from './local-storage-codec.js';
+import { normalizeFpSvgLayerAliases } from './normalize-fp-svg.js';
+import { normalizeLegacyData } from './normalize-legacy-data.js';
+import { applyRebookingData } from './rebooking.js';
+import { parseFromUrlTolerant } from './url-codec.js';
+import { parseIntentsFromUrl } from './url-intents.js';
+import { readValidateFlag } from './validate-flag.js';
+import { documentRef, setValidateManifest, validateOrClone } from './visit-resources.js';
+const log = debug('efp:config');
+/**
+ * Assemble the effective config — the runtime's single, complete copy of the
+ * expo data — by layering, lowest to highest precedence:
+ * manifest (+ its legacy data.js) → options → localStorage → URL.
+ *
+ * With a `legacyDataUrlBase` (live events), the version probe settles the
+ * `?v=` cache-buster, refs to the sibling drawing / wayfinding files are
+ * derived from it (`data.js` never carries them), and all three legacy files —
+ * `data.js` evaluated to its `__data` document like every legacy `.js` file,
+ * asset-resolved and merged in — are fetched in parallel. A manifest can
+ * instead carry the merged data itself plus explicit refs (offline copies) —
+ * then nothing is derived. The config holds only the REFS; the payloads live
+ * in `@expofp/resolve`'s memo: `loadConfig` resolves `fpSvgJsRef` and
+ * `wfDataJsRef` before returning, so consumers read them synchronously with
+ * `getResolved` from then on. Legacy normalization and the rebooking merge
+ * run last, and the result is deep-frozen.
+ *
+ * `url` / `storage` are browser inputs (page query, `localStorage`); Node
+ * callers (the offline CLI) omit them, which also skips those layers and the
+ * rebooking token lookup.
+ */
+export async function loadConfig(manifest, options, url, storage) {
+    const config = { ...ConfigDefaults };
+    // Schema validation is an opt-in diagnostic, read up front from the page
+    // inputs (URL query / localStorage): the parses it gates run before those
+    // layers merge, so it can't come off the effective config. See readValidateFlag.
+    const validateSchema = readValidateFlag(url, storage);
+    setValidateManifest(validateSchema); // gates the referenced-document parses (visit-resources)
+    // Take an OWN copy of the resolved manifest (validated when the flag is on —
+    // see validateOrClone): `resolve` deep-freezes what it settles, an offline
+    // manifest carries the full event data (booths, exhibitors, …), and
+    // `normalizeLegacyData` below mutates those nested objects in place.
+    manifest = validateOrClone(ManifestSchema, await resolve(manifest));
+    // The legacy event-data directory (and the old manifests' version pointer,
+    // replaced by the version.json probe) are INPUTS, consumed right here — the
+    // effective config carries only the refs derived from them, so neither is
+    // merged.
+    const { legacyDataUrlBase, legacyDataVersion: _manifestVersion, ...manifestFields } = manifest;
+    applyConsentAlias(manifestFields);
+    assignDefined(config, manifestFields);
+    // don't trust, parse
+    options = OptionsSchema.parse(options);
+    applyConsentAlias(options);
+    // every legacy file URL is ?v= cache-busted; a timestamp busts when no
+    // version.json exists (TODO: drop once the legacy data directory is gone)
+    let legacyDataVersion = String(Date.now());
+    // live legacy directory: version probe, then the sibling file refs — data.js
+    // never carries the payload refs, so both are known before it lands
+    if (legacyDataUrlBase) {
+        if (isFromDesignerReferrer()) {
+            // The designer previews in-progress edits — the directory's files change
+            // without a version bump, so the published version must not pin `?v=`;
+            // the unique timestamp stands and every load fetches fresh files.
+            log('loadConfig', 'designer referrer — cache-busting with a timestamp');
+        }
+        else {
+            try {
+                legacyDataVersion = (await resolve({ $ref: `${legacyDataUrlBase}version.json` })).version;
+            }
+            catch {
+                log('loadConfig', 'no version.json found at', legacyDataUrlBase);
+            }
+        }
+        // Manifest-supplied refs win (offline copies point them at resolved .json
+        // documents); otherwise derive the conventional <base><file>.js URLs.
+        config.fpSvgJsRef ??= legacyFileRef(legacyDataUrlBase, 'fp.svg.js', legacyDataVersion);
+        config.wfDataJsRef ??= legacyFileRef(legacyDataUrlBase, 'wf.data.js', legacyDataVersion);
+    }
+    // Every ref the config carries is decorated with its document-processing
+    // hook (validate + absolutize resource URLs against the ref's directory) —
+    // after the manifest parse, which keeps refs as plain data, and covering
+    // manifest-supplied and derived refs alike. From here on, ANY
+    // `resolve(ref)` settles a good document.
+    if (config.fpSvgJsRef)
+        config.fpSvgJsRef = documentRef(config.fpSvgJsRef, FpSvgJsSchema);
+    if (config.wfDataJsRef)
+        config.wfDataJsRef = documentRef(config.wfDataJsRef, WfDataJsSchema);
+    const layerRefs = {};
+    for (const [name, ref] of Object.entries(config.fpSvgLayerJsRefs)) {
+        layerRefs[name] = fpSvgLayerDocumentRef(ref, name);
+    }
+    config.fpSvgLayerJsRefs = layerRefs;
+    // Resolve the expo data document, the drawing and the wayfinding graph
+    // eagerly, in parallel — one network round-trip instead of three. Works with
+    // or without a legacy directory (an offline manifest carries the merged
+    // data plus refs, and no directory). The payloads stay in the resolver's
+    // memo; consumers read them synchronously with `getResolved`.
+    const [data, fpSvg] = await Promise.all([
+        legacyDataUrlBase ? loadLegacyDataJs(legacyDataUrlBase, legacyDataVersion) : null,
+        config.fpSvgJsRef ? loadLegacyFpSvgJs(config.fpSvgJsRef, legacyDataUrlBase) : null,
+        prefetchWfData(config.wfDataJsRef),
+    ]);
+    if (data) {
+        // the directory fields and the payload refs are inputs consumed above —
+        // data.js never carries them, and a stray copy must not clobber the
+        // decorated, already-resolved refs
+        const { flags, legacyDataUrlBase: _dataDir, legacyDataVersion: _dataVersion, fpSvgJsRef: _fpRef, wfDataJsRef: _wfRef, fpSvgLayerJsRefs: _layerRefs, ...dataFields } = data;
+        if (flags) {
+            // legacy data.js may nest the deprecated alias under `flags`; fold it too
+            applyConsentAlias(flags);
+            assignDefined(config, flags); // deprecated nesting — root-level fields win
+        }
+        applyConsentAlias(dataFields);
+        assignDefined(config, dataFields);
+    }
+    if (fpSvg) {
+        // a pending-poll may have landed on a fresh ?v= URL — the config must
+        // point at the ref that actually resolved
+        config.fpSvgJsRef = fpSvg.ref;
+        if (!Object.keys(config.fpSvgLayerJsRefs).length && legacyDataUrlBase) {
+            config.fpSvgLayerJsRefs = buildFpSvgLayerJsRefs(fpSvg.payload, legacyDataUrlBase, legacyDataVersion);
+        }
+    }
+    assignDefined(config, options);
+    if (storage) {
+        // The sticky per-browser preferences (viewerMode / previewMode / uiScale)
+        // are schema-typed storage settings but must NOT merge into the effective
+        // config: the floor plan reads their keys lazily, so the legacy one-shot
+        // URL seeds (`?viewermode=0`, `?resetuiscale`, …) stay revocable within
+        // the same load — a frozen config value would keep a cleared mode on.
+        const { viewerMode: _viewerMode, previewMode: _previewMode, uiScale: _uiScale, ...storageConfig } = parseFromStorage(LocalStorageConfigSchema, storage);
+        assignDefined(config, storageConfig);
+    }
+    // Embeds set `ignoreQuery` (manifest / data.js / options) to isolate the
+    // floor plan from the page URL. The effective value is settled here — every
+    // lower layer has merged, and the URL cannot re-enable itself because
+    // `ignoreQuery` is not a UrlConfigSchema field.
+    if (url !== undefined && !config.ignoreQuery) {
+        // tolerant: the query is visitor-editable, a bad value must not break boot
+        const { value: urlConfig, invalidKeys } = parseFromUrlTolerant(UrlConfigSchema, url);
+        // shortcut intents (`?selectBooth=A-12`) append after the bracketed
+        // `intents[…]` entries — both play, canonical form first
+        const shortcuts = parseIntentsFromUrl(url);
+        if (shortcuts.intents.length) {
+            urlConfig.intents = [...(urlConfig.intents ?? []), ...shortcuts.intents];
+        }
+        invalidKeys.push(...shortcuts.invalidKeys);
+        if (invalidKeys.length)
+            log('loadConfig', 'ignoring invalid URL config params:', invalidKeys);
+        applyConsentAlias(urlConfig);
+        assignDefined(config, urlConfig);
+    }
+    normalizeLegacyData(config, legacyDataUrlBase);
+    // `ignoreQuery` means "isolate from the page URL": don't read the rebooking
+    // token (`?rt=`) from it either — pass no URL so a retained session token is
+    // still honored but the query is not.
+    await applyRebookingData(config, config.ignoreQuery ? undefined : url);
+    // validateSchema is a load-time input (read up front by readValidateFlag), not
+    // a config field — strip it so the effective config never carries it, like the
+    // deprecated allowConsent alias.
+    delete config.validateSchema;
+    deepFreeze(config);
+    return config;
+}
+async function loadLegacyDataJs(baseUrl, version) {
+    // data.js is a window-assigning script like fp.svg.js — resolve() evaluates
+    // it to its globals and the expo data document rides on `__data`. The
+    // decorated ref validates the payload (gated) and makes every schema-tagged
+    // asset path absolute against its directory (= baseUrl).
+    const payload = await resolve(documentRef(legacyFileRef(baseUrl, 'data.js', version), DataJsSchema));
+    if (!payload.__data)
+        log('loadLegacyDataJs', 'no __data global in data.js at', baseUrl);
+    // the resolver's memoized payload is frozen — the merge and normalization
+    // write into an own copy (a clone, so nothing here depends on parse)
+    return deepClone(payload.__data ?? {});
+}
+/** Retry cadence while the platform is still generating the plan (`__fpPending`). */
+const FP_SVG_PENDING_RETRY_MS = 2000;
+/**
+ * Resolve `fp.svg.js` eagerly (a script evaluated to its globals live, a
+ * resolved `fp.svg.json` document offline). A still-generating plan serves a
+ * `{ __fpPending: true }` stub instead of the drawing; poll — with a fresh
+ * `?v=` per attempt to step around CDN caching — until the real payload lands.
+ * Returns the payload (for layer-ref derivation) and the ref that finally
+ * resolved, which is what the config must carry for `getResolved`.
+ */
+async function loadLegacyFpSvgJs(ref, baseUrl) {
+    let finalRef = ref; // already decorated by loadConfig
+    let fpSvgJs = await resolve(finalRef);
+    for (let attempt = 1; fpSvgJs.__fpPending && !fpSvgJs.__fp; attempt++) {
+        log('loadLegacyFpSvgJs', 'plan is still generating, retry', attempt);
+        await sleep(FP_SVG_PENDING_RETRY_MS);
+        // a fresh ?v= per attempt steps around CDN caching; an explicit ref (a
+        // resolved offline .json is never pending-stubbed) re-resolves as-is
+        finalRef = baseUrl
+            ? documentRef(legacyFileRef(baseUrl, 'fp.svg.js', String(attempt)), FpSvgJsSchema)
+            : ref;
+        fpSvgJs = await resolve(finalRef, { forceFetch: true });
+    }
+    return { payload: fpSvgJs, ref: finalRef };
+}
+/**
+ * Warm the wayfinding graph ref (`wf.data.js` live, `wf.data.json` offline).
+ * A plan without a graph used to load as a silent no-op script, so a failure
+ * only logs; the ref stays unsettled and consumers probing with `isResolved`
+ * keep wayfinding off.
+ */
+async function prefetchWfData(ref) {
+    if (!ref)
+        return;
+    try {
+        await resolve(ref); // decorated by loadConfig
+    }
+    catch (err) {
+        log('prefetchWfData', 'wf.data.js not loaded, wayfinding stays off', err);
+    }
+}
+/**
+ * Decorate one layer's drawing ref: the standard document processing, plus
+ * the fold of the layer-suffixed drawing globals onto the canonical keys —
+ * newer converters emit only the suffixed globals in layer files (see
+ * `normalizeFpSvgLayerAliases`).
+ */
+function fpSvgLayerDocumentRef(ref, layerName) {
+    return documentRef(ref, FpSvgLayerJsSchema, (document) => normalizeFpSvgLayerAliases(document, layerName));
+}
+/**
+ * One `$ref` per non-default layer, pointing at its `fp.svg.<layerName>.js`
+ * (the default layer's drawing is `fp.svg.js` itself, already resolved).
+ * Layer data is not fetched here — a consumer resolves a layer's ref on
+ * demand and reads it back with `getResolved`.
+ */
+function buildFpSvgLayerJsRefs(fpSvgJs, baseUrl, version) {
+    const refs = {};
+    for (const layer of fpSvgJs.__fpLayers ?? []) {
+        if (layer.name === fpSvgJs.__fpDefaultLayer)
+            continue;
+        refs[layer.name] = fpSvgLayerDocumentRef(legacyFileRef(baseUrl, `fp.svg.${layer.name}.js`, version), layer.name);
+    }
+    return refs;
+}
+/**
+ * True when the page is embedded by the ExpoFP designer, which previews
+ * in-progress edits: the legacy directory's files then change without a
+ * `version.json` bump, so the published version must not pin the `?v=`
+ * cache-buster. A browser-only signal — in Node (the offline CLI) there is no
+ * document and no designer. Mirrors the floorplan's `utils/is-from-designer`.
+ */
+function isFromDesignerReferrer() {
+    if (typeof document === 'undefined' || !document.referrer)
+        return false;
+    return (document.referrer.includes('app.expofp.com') ||
+        document.referrer.includes('app-show.expofp.com'));
+}
+/** `$ref` to a file in the legacy data directory, `?v=` cache-busted like all legacy loads. */
+function legacyFileRef(baseUrl, fileName, version) {
+    const url = `${baseUrl}${fileName}`;
+    return { $ref: version ? `${url}?v=${version}` : url };
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Fold one input layer's deprecated `allowConsent` boolean into `consent`
+ * (`true` → `'granted'`, `false` → `'denied'`) before that layer merges, so
+ * cross-layer precedence stays exact: a layer's own `consent` beats its own
+ * alias, and a higher layer's alias still beats a lower layer's `consent`.
+ */
+function applyConsentAlias(layer) {
+    if (layer.allowConsent !== undefined) {
+        layer.consent ??= layer.allowConsent ? 'granted' : 'denied';
+        delete layer.allowConsent;
+    }
+}
+/** `Object.assign`, except a key explicitly set to `undefined` never erases a lower layer. */
+function assignDefined(target, source) {
+    for (const [key, value] of Object.entries(source)) {
+        if (value !== undefined) {
+            target[key] = value;
+        }
+    }
+}