@expofp/schema 3.11.12

package/dist/lib/config.js

@@ -0,0 +1,340 @@
+import * as z from 'zod';
+import { RawBoothSchema } from './booth.js';
+import { CameraSchema } from './camera.js';
+import { RawCategorySchema } from './categories.js';
+import { LegacyLogoSchema, RawExhibitorSchema } from './exhibitor.js';
+import { FiltersSchema } from './filters.js';
+import { FlagsSchema } from './flags.js';
+import { FpSvgJsRefSchema, FpSvgLayerJsRefSchema } from './fp-svg.js';
+import { HeatmapSchema } from './heatmap.js';
+import { IntentsSchema } from './intents.js';
+import { KioskSchema } from './kiosk.js';
+import { MapLibreConfigSchema } from './maplibre.js';
+import { RawPoiTypeSchema } from './poi-types.js';
+import { ScheduleItemSchema } from './schedule.js';
+import { FilterButtonsConfigSchema } from './search.js';
+import { VisibilitySchema } from './visibility.js';
+import { WfDataJsRefSchema } from './wayfinding.js';
+// The document schemas below are LOOSE objects (`z.looseObject`): the platform
+// emits fields faster than this file learns them, and the effective config is
+// the runtime's ONLY copy of the expo data — a stripping parse would silently
+// lose anything unmodeled. Fields are declared for typing, docs and `asset`
+// tagging (read by `@expofp/config`'s `visitResources` walk); everything else
+// passes through.
+/**
+ * One `customCssFonts` entry — a web font to load alongside custom CSS.
+ *
+ * Deliberately tolerant: `customCssFonts` is rare, author-authored platform
+ * data, and this schema now *validates* `data.js` (a shape slip used to be
+ * harmless on the untyped `window.__data`). Requiring the fields would let a
+ * numeric `weight` or a missing `style`/`url` throw and abort the whole config
+ * load — the label renderer already coerces `weight` with `+` and falls back to
+ * the default font when a field is absent, so a bad entry should degrade, not
+ * fail boot.
+ */
+const FontUrlSchema = z.looseObject({
+    weight: z.union([z.string(), z.number()]).optional(),
+    style: z.string().optional(),
+    url: z.string().meta({ asset: true }).optional(),
+});
+/**
+ * The cookie-consent decision for analytics. `'granted'` / `'denied'` apply a
+ * pre-made decision — no consent prompt, analytics on/off accordingly. `'ask'`
+ * (the default) leaves the decision to the visitor: GDPR visitors get the
+ * consent prompt, everyone else falls back to the regional gtag defaults.
+ */
+export const ConsentSchema = z.enum(['ask', 'granted', 'denied']);
+// this one presented to the world
+export const ConfigSchema = z.object({
+    expo: z.string(),
+    intents: z.array(IntentsSchema),
+    // The config carries only REFS to the legacy payload documents — the
+    // resolved payloads live in @expofp/resolve's memo (`getResolved`).
+    // `loadConfig` resolves fpSvgJsRef and wfDataJsRef eagerly before it
+    // returns, so they are always warm; layer refs resolve on demand.
+    /** `fp.svg.js` ref (the drawing); null derives `<legacyDataUrlBase>fp.svg.js`. */
+    fpSvgJsRef: FpSvgJsRefSchema.nullable(),
+    /** Per-layer `fp.svg.<layerName>.js` refs (by layer name), resolved on demand. */
+    fpSvgLayerJsRefs: z.record(z.string(), FpSvgLayerJsRefSchema),
+    /** `wf.data.js` (wayfinding graph) ref; null without legacy data. */
+    wfDataJsRef: WfDataJsRefSchema.nullable(),
+    // data.js (__data)
+    noFeatured: z.boolean(),
+    isTrial: z.boolean(),
+    expoFpAd: z.boolean(),
+    free: z.boolean(),
+    trialExpiresAt: z.string(),
+    title: z.string(),
+    subtitle: z.string(),
+    homeUrl: z.string(),
+    registerUrl: z.string(),
+    startDate: z.string(),
+    endDate: z.string(),
+    // `optionalAsset`: the effective logo can be a data-dir-relative *guess* —
+    // `normalizeLegacyData` fabricates `<expo>-logo.png` when data.js carries no
+    // logo — so a 404 must warn-and-skip during offline generation, not abort the
+    // whole archive (an event logo is non-critical branding).
+    logo: z.string().meta({ asset: true, optionalAsset: true }),
+    gallery: z.array(LegacyLogoSchema),
+    gtag: z.string(),
+    boothTerm: z.string(),
+    levelTerm: z.string(),
+    reserveButtonTerm: z.string(),
+    exhibitorTerm: z.string(),
+    exhibitorTermPlural: z.string(),
+    locale: z.string(),
+    booths: z.array(RawBoothSchema),
+    exhibitors: z.array(RawExhibitorSchema),
+    categories: z.array(RawCategorySchema),
+    poiTypes: z.array(RawPoiTypeSchema),
+    reserveInstructions: z.string(),
+    sendLoginLinkUrl: z.string(),
+    trackerUrl: z.string(),
+    hideWayInformation: z.boolean(),
+    hideDirections: z.boolean(),
+    hideExhibitors: z.boolean(),
+    onlyFeaturedExhibitors: z.boolean(),
+    hideExhibitorBoothNumber: z.boolean(),
+    dimensionless: z.boolean(),
+    hideCategoriesLink: z.boolean(),
+    hideEventHomeLink: z.boolean(),
+    hideRegisterToAttendLink: z.boolean(),
+    hideDownloadPdfLink: z.boolean(),
+    hideBookmarksLink: z.boolean(),
+    hideBookmarks: z.boolean(),
+    hideLanguage: z.boolean(),
+    hideLanguageLink: z.boolean(),
+    autoTrackingGps: z.boolean(),
+    enableIPS: z.boolean(),
+    allow3dView: z.boolean(),
+    hide3dMapDefault: z.boolean(),
+    hideModeSwitchButton: z.boolean(),
+    isRebooking: z.boolean(),
+    events: z.array(ScheduleItemSchema),
+    customCss: z.string().meta({ cssAsset: true }),
+    customCssFonts: z.array(FontUrlSchema),
+    showLevelLabel: z.boolean(),
+    showCategories: z.boolean(),
+    showCompaniesAndBooths: z.boolean(),
+    showOtherSpaces: z.boolean(),
+    hideShareButton: z.boolean(),
+    viewOptimizationLevel: z.number(),
+    shortLevelName: z.boolean(),
+    searchText: z.string(),
+    filterButtonsConfig: FilterButtonsConfigSchema,
+    enableRotation: z.boolean(),
+    alwaysShowSidebar: z.boolean(),
+    customKioskQrCodeUrl: z.string(),
+    ...FlagsSchema.shape,
+    // user preferences
+    /** Debug mode: verbose logs, the in-map debug overlay, dev-leniency in error paths. */
+    debugMode: z.boolean(),
+    debugPattern: z.string(),
+    showDebugButton: z.boolean(),
+    // options
+    previewMode: z.boolean(),
+    noOverlay: z.boolean(),
+    offHistory: z.boolean(),
+    ignoreQuery: z.boolean(),
+    consent: ConsentSchema,
+    viewerMode: z.boolean(),
+    disableRuntimeAlerts: z.boolean(),
+    maplibre: MapLibreConfigSchema,
+    // presentation toggles, historically one-shot URL params scrubbed by the
+    // legacy router; now ordinary config fields every layer (manifest, options,
+    // localStorage, URL) can set
+    /** Render the plan in grayscale. */
+    monochrome: z.boolean(),
+    /** Hide the header logo (and the ExpoFP logo). */
+    hideHeaderLogo: z.boolean(),
+    /** Hide exhibitor logos inside booths. */
+    hideLogoInBooth: z.boolean(),
+    /** Drop the `featured` flag from every exhibitor (no featured view). */
+    disableFeatured: z.boolean(),
+    /** Disable adding entities to bookmarks. */
+    disableBookmarked: z.boolean(),
+    /** Start with GPS tracking off. */
+    disableGps: z.boolean(),
+    /**
+     * The initial camera, applied once at boot (an empty object means "don't
+     * move"). The runtime counterpart is `FloorPlan.setCamera` / the `setCamera`
+     * intent; the legacy `?centerxy=`/`?center=`/`?z=`/`?bearing=`/`?zoomtime=`
+     * URL params translate into this shape.
+     */
+    camera: CameraSchema,
+    /**
+     * Visibility of the map chrome, applied once at boot (an empty object leaves
+     * the chrome untouched; a non-empty one resets every omitted element to
+     * visible — the legacy `?hide=` list semantics). The runtime counterpart is
+     * `FloorPlan.setVisibility` / the `setVisibility` intent; the legacy
+     * `?hide=a,b` deep link keeps its store-level translation.
+     */
+    visibility: VisibilitySchema,
+    /**
+     * Search filters applied once at boot by the URL filter manager (an empty
+     * object applies nothing). Canonical URL form `?filters[categories][0]=food`;
+     * the legacy `?categories=`/`?poiType=`/`?poiTypes=`/`?exhibitors=true` keys
+     * keep working — and remain the form the floor plan writes back to the URL
+     * as the visitor changes filters.
+     */
+    filters: FiltersSchema,
+    /**
+     * Heatmap mode, engaged once at boot (an empty object — the default — means
+     * no heatmap). A non-empty node engages the mode unless `enabled` is
+     * explicitly `false`, so `heatmap: { variant: 'yah' }` implies enabled;
+     * `variant` picks the dataset (`booths` view stats by default, `yah` for
+     * "You are here" QR scans; `kiosk: true` narrows `yah` to kiosk positions).
+     * Heatmap mode freezes the page URL for the whole session (the legacy
+     * contract). The legacy `?heatmap=true&type=yah&subtype=kiosk` links keep
+     * working as a translation; the access token `?t=` stays a separate raw
+     * query param, not config.
+     */
+    heatmap: HeatmapSchema,
+    /**
+     * The kiosk anchor — where a kiosk device stands and how its camera is
+     * framed, applied at boot when the device has no locally-saved kiosk (the
+     * on-device SetKiosk flow wins; `localStorage['kiosk']='0'` disables both).
+     * Canonical URL form `?kiosk[x]=…`; the legacy `kiosk_*` params stay the
+     * per-navigation translation and `?kiosk=1/0` keeps toggling kiosk mode.
+     */
+    kiosk: KioskSchema,
+});
+/**
+ * Deprecated `allowConsent` input alias, accepted by every input schema and
+ * folded into `consent` by `loadConfig` (`true` → `'granted'`, `false` →
+ * `'denied'`; a layer's own `consent` wins). The effective config never
+ * carries it.
+ */
+const DeprecatedConsentAlias = {
+    allowConsent: z.boolean().optional(),
+};
+/**
+ * Load-time diagnostic inputs — accepted from the URL query and localStorage but
+ * NEVER carried on the effective config (`loadConfig` reads them up front, then
+ * strips them before the config is frozen). So far only `validateSchema`: it
+ * gates schema validation during the load itself (consumed by `@expofp/config`'s
+ * `readValidateFlag`) and is meaningless once the config exists — hence kept off
+ * `ConfigSchema`, like the deprecated `allowConsent` alias above.
+ */
+const LoadDiagnostics = {
+    validateSchema: z.boolean().optional(),
+};
+/**
+ * The expo data document — the `__data` global of the legacy `data.js`: every
+ * config field optional, plus the deprecated nested `flags`.
+ */
+export const DataSchema = z.looseObject({
+    ...ConfigSchema.partial().shape,
+    ...DeprecatedConsentAlias,
+    flags: FlagsSchema.optional().meta({ description: 'deprecated, use root-level fields' }),
+});
+/**
+ * The evaluated `data.js` payload. Like `fp.svg.js`, the file is a classic
+ * window-assigning browser script (`window.__data = …`) that `resolve`
+ * (`@expofp/resolve`) evaluates to its globals; the expo data document rides
+ * on `__data`.
+ */
+export const DataJsSchema = z.looseObject({
+    __data: DataSchema.optional(),
+});
+// manifest, options, localStorage, URL -> all fields optional
+// result config - all fields are set, except raw (bool/string that are empty)
+// Loose for the same reason as DataSchema: an offline copy's manifest IS
+// the merged expo data, so unmodeled fields must survive the parse.
+export const ManifestSchema = z.looseObject({
+    ...ConfigSchema.partial().required({ expo: true }).shape,
+    ...DeprecatedConsentAlias,
+    /**
+     * The legacy expo-data directory (`data.js`, `fp.svg.js`, …). Consumed by
+     * `loadConfig` to fetch the document and derive the payload refs — it is NOT
+     * carried on the effective config; nothing outside the config package ever
+     * sees it.
+     */
+    legacyDataUrlBase: z.string().optional(),
+});
+/**
+ * Caller-supplied overrides — the config fields a host may set when embedding
+ * the floor plan (`load(manifest, options)`). Deliberately EXPLICIT (a `pick`,
+ * not `ConfigSchema.partial()`): the expo data proper — booths, exhibitors,
+ * branding, feature flags — comes from the manifest / `data.js`, so `loadConfig`
+ * parses the options layer and strips anything outside this set. `allowConsent`
+ * is the deprecated alias for `consent`.
+ */
+export const OptionsSchema = ConfigSchema.partial()
+    .pick({
+    previewMode: true,
+    noOverlay: true,
+    offHistory: true,
+    ignoreQuery: true,
+    consent: true,
+    viewerMode: true,
+    disableRuntimeAlerts: true,
+    maplibre: true,
+})
+    .extend(DeprecatedConsentAlias);
+/** The subset tunable from the page URL query. */
+export const UrlConfigSchema = ConfigSchema.partial()
+    .pick({
+    enableExperimentalMaplibre: true,
+    intents: true,
+    consent: true,
+    // the former one-shot presentation params — the query keys keep their
+    // historical names, which match these field names exactly
+    noOverlay: true,
+    monochrome: true,
+    hideHeaderLogo: true,
+    hideLogoInBooth: true,
+    disableFeatured: true,
+    disableBookmarked: true,
+    disableGps: true,
+    // the canonical camera form: ?camera[x]=6517&camera[y]=3826&camera[bearing]=180
+    camera: true,
+    // the canonical visibility form: ?visibility[header]=false
+    visibility: true,
+    // the canonical filters form: ?filters[categories][0]=food — the legacy
+    // `categories`/`poiType(s)`/`exhibitors` keys stay OUT of this pick: they
+    // live in the URL as the filter manager's property and are never scrubbed
+    filters: true,
+    // the canonical heatmap form: ?heatmap[variant]=yah&heatmap[enabled]=true
+    // (the legacy scalar ?heatmap=true is not this node's shape — it stays a
+    // legacy-URL one-shot and drops out of the tolerant config parse)
+    heatmap: true,
+    // the canonical kiosk-anchor form: ?kiosk[x]=6517&kiosk[y]=3826 — the
+    // legacy scalar ?kiosk=1/0 (the mode toggle) is not this node's shape: it
+    // drops out of the tolerant parse and keeps its params-based primary
+    kiosk: true,
+})
+    .extend(DeprecatedConsentAlias)
+    .extend(LoadDiagnostics);
+/**
+ * The subset persisted per-user in localStorage.
+ *
+ * `viewerMode` / `previewMode` / `uiScale` are schema-typed here (their keys
+ * are `efp-viewerMode` / `efp-previewMode` / `efp-uiScale`) but deliberately
+ * NOT merged into the effective config by `loadConfig`: the floor plan reads
+ * them from storage lazily, which is what keeps the legacy one-shot URL seeds
+ * (`?viewermode=` / `?previewMode=` / `?uiscale=`, which write these keys)
+ * effective within the same load — a frozen config value could not be
+ * revoked by a same-load disable seed.
+ */
+export const LocalStorageConfigSchema = ConfigSchema.partial()
+    .pick({
+    enableExperimentalMaplibre: true,
+    debugMode: true,
+    debugPattern: true,
+    showDebugButton: true,
+    viewerMode: true,
+    previewMode: true,
+})
+    .extend({
+    /**
+     * Per-browser UI-scale preference (0.8–1.4), seeded by the legacy
+     * `?uiscale=` param. Not a `ConfigSchema` field: nothing consumes a
+     * config-level uiScale — the floor plan UI reads the storage key
+     * directly. Tolerant (`catch`): a hand-edited or out-of-range stored
+     * value reads as absent instead of failing the whole storage layer at
+     * boot.
+     */
+    uiScale: z.number().min(0.8).max(1.4).optional().catch(undefined),
+})
+    .extend(LoadDiagnostics);

package/dist/lib/exhibitor.d.ts

@@ -0,0 +1,65 @@
+import * as z from 'zod';
+/** A marketing asset an exhibitor uploads — an entry in `marketMaterials`. */
+export declare const MarketMaterialSchema: z.ZodObject<{
+    fileName: z.ZodString;
+    path: z.ZodString;
+}, z.core.$loose>;
+/** The legacy string logo form — a bare asset URL. */
+export declare const LegacyLogoSchema: z.ZodString;
+/**
+ * The object logo form, carrying pre-scaled variant URLs. The variants are
+ * minted from the full URL without an existence check (`optionalAsset`), so
+ * the platform may never have produced the files — consumers fall back to
+ * `url`, and the offline generator skips a missing variant instead of failing.
+ */
+export declare const LogoSchema: z.ZodObject<{
+    url: z.ZodString;
+    smallUrl: z.ZodOptional<z.ZodString>;
+    tinyUrl: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const RawExhibitorSchema: z.ZodObject<{
+    id: z.ZodNonOptional<z.ZodOptional<z.ZodNumber>>;
+    name: z.ZodNonOptional<z.ZodOptional<z.ZodString>>;
+    externalId: z.ZodOptional<z.ZodString>;
+    featured: z.ZodOptional<z.ZodBoolean>;
+    advertise: z.ZodOptional<z.ZodBoolean>;
+    description: z.ZodOptional<z.ZodString>;
+    address: z.ZodOptional<z.ZodString>;
+    address2: z.ZodOptional<z.ZodString>;
+    city: z.ZodOptional<z.ZodString>;
+    state: z.ZodOptional<z.ZodString>;
+    zip: z.ZodOptional<z.ZodString>;
+    country: z.ZodOptional<z.ZodString>;
+    phone1: z.ZodOptional<z.ZodString>;
+    website: z.ZodOptional<z.ZodString>;
+    facebook: z.ZodOptional<z.ZodString>;
+    instagram: z.ZodOptional<z.ZodString>;
+    linkedin: z.ZodOptional<z.ZodString>;
+    twitter: z.ZodOptional<z.ZodString>;
+    googlePlus: z.ZodOptional<z.ZodString>;
+    xing: z.ZodOptional<z.ZodString>;
+    youtube: z.ZodOptional<z.ZodString>;
+    email: z.ZodOptional<z.ZodString>;
+    privateEmail: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    logo: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodObject<{
+        url: z.ZodString;
+        smallUrl: z.ZodOptional<z.ZodString>;
+        tinyUrl: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>;
+    logoInBooth: z.ZodOptional<z.ZodBoolean>;
+    gallery: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    marketMaterials: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        fileName: z.ZodString;
+        path: z.ZodString;
+    }, z.core.$loose>>>;
+    categories: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    leadingImageUrl: z.ZodOptional<z.ZodString>;
+    videoUrl: z.ZodOptional<z.ZodString>;
+    rebookingState: z.ZodOptional<z.ZodNumber>;
+    rebookingNote: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export type RawExhibitor = z.infer<typeof RawExhibitorSchema>;
+export type MarketMaterial = z.infer<typeof MarketMaterialSchema>;
+export type Logo = z.infer<typeof LogoSchema>;
+//# sourceMappingURL=exhibitor.d.ts.map

package/dist/lib/exhibitor.js

@@ -0,0 +1,67 @@
+import * as z from 'zod';
+/** A marketing asset an exhibitor uploads — an entry in `marketMaterials`. */
+export const MarketMaterialSchema = z.looseObject({
+    fileName: z.string(),
+    path: z.string().meta({ asset: true }),
+});
+/** The legacy string logo form — a bare asset URL. */
+export const LegacyLogoSchema = z.string().meta({ asset: true });
+/**
+ * The object logo form, carrying pre-scaled variant URLs. The variants are
+ * minted from the full URL without an existence check (`optionalAsset`), so
+ * the platform may never have produced the files — consumers fall back to
+ * `url`, and the offline generator skips a missing variant instead of failing.
+ */
+export const LogoSchema = z.object({
+    url: z.string().meta({ asset: true }),
+    smallUrl: z.string().optional().meta({ asset: true, optionalAsset: true }),
+    tinyUrl: z.string().optional().meta({ asset: true, optionalAsset: true }),
+});
+/**
+ * An exhibitor logo. The platform still emits the legacy string form on input;
+ * `normalizeLegacyData` (`@expofp/config`) converts it to {@link LogoSchema} —
+ * the pre-scaled `__small`/`__tiny` siblings become explicit variant URLs — so
+ * the EFFECTIVE config only ever carries the object form. Plain code, not a zod
+ * transform: parse is validation only (gated by the opt-in `validateSchema` flag) and the
+ * pipeline must work without it.
+ */
+const ExhibitorLogoSchema = LegacyLogoSchema.or(LogoSchema);
+export const RawExhibitorSchema = z
+    .looseObject({
+    id: z.number(),
+    name: z.string(),
+    externalId: z.string(),
+    featured: z.boolean(),
+    advertise: z.boolean(),
+    description: z.string(),
+    address: z.string(),
+    address2: z.string(),
+    city: z.string(),
+    state: z.string(),
+    zip: z.string(),
+    country: z.string(),
+    phone1: z.string(),
+    website: z.string(),
+    facebook: z.string(),
+    instagram: z.string(),
+    linkedin: z.string(),
+    twitter: z.string(),
+    googlePlus: z.string(),
+    xing: z.string(),
+    youtube: z.string(),
+    email: z.string(),
+    privateEmail: z.string(),
+    order: z.number(),
+    logo: ExhibitorLogoSchema,
+    /** Paint the logo inside the exhibitor's booth shape on the drawing. */
+    logoInBooth: z.boolean(),
+    gallery: z.array(LegacyLogoSchema),
+    marketMaterials: z.array(MarketMaterialSchema),
+    categories: z.array(z.number()),
+    leadingImageUrl: z.string().meta({ asset: true }),
+    videoUrl: z.string(),
+    rebookingState: z.number(),
+    rebookingNote: z.string(),
+})
+    .partial()
+    .required({ id: true, name: true });

package/dist/lib/filters.d.ts

@@ -0,0 +1,23 @@
+import * as z from 'zod';
+/**
+ * Boot-time search filters — the `config.filters` node, applied once by the
+ * floor plan's URL filter manager when the stores are ready. Values are plain
+ * catalog names (no URL encoding), matched case-insensitively; unknown names
+ * warn and drop, and `categories` win over POI types when both are given.
+ *
+ * `poiType` (single) and `poiTypes` (multi) are deliberately distinct fields —
+ * not one array as the retirement-plan sketch had it — because their apply
+ * paths differ: the single form also activates the matching search filter
+ * button (`setPoiFilterId`), while the multi form only pre-selects the
+ * filters. Folding them into one array would silently change what a
+ * one-element list does.
+ */
+export declare const FiltersSchema: z.ZodObject<{
+    categories: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    poiType: z.ZodOptional<z.ZodString>;
+    poiTypes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    exhibitors: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export interface Filters extends z.infer<typeof FiltersSchema> {
+}
+//# sourceMappingURL=filters.d.ts.map

package/dist/lib/filters.js

@@ -0,0 +1,24 @@
+import * as z from 'zod';
+/**
+ * Boot-time search filters — the `config.filters` node, applied once by the
+ * floor plan's URL filter manager when the stores are ready. Values are plain
+ * catalog names (no URL encoding), matched case-insensitively; unknown names
+ * warn and drop, and `categories` win over POI types when both are given.
+ *
+ * `poiType` (single) and `poiTypes` (multi) are deliberately distinct fields —
+ * not one array as the retirement-plan sketch had it — because their apply
+ * paths differ: the single form also activates the matching search filter
+ * button (`setPoiFilterId`), while the multi form only pre-selects the
+ * filters. Folding them into one array would silently change what a
+ * one-element list does.
+ */
+export const FiltersSchema = z.object({
+    /** Category names to pre-select; opens the category filter panel. */
+    categories: z.array(z.string()).optional(),
+    /** A single POI type to pre-select; also activates its search filter button. */
+    poiType: z.string().optional(),
+    /** POI type names to pre-select (no filter-button activation). */
+    poiTypes: z.array(z.string()).optional(),
+    /** `true` opens the exhibitors list at boot. */
+    exhibitors: z.boolean().optional(),
+});

package/dist/lib/flags.d.ts

@@ -0,0 +1,23 @@
+import * as z from 'zod';
+/**
+ * Feature flags. Historically a nested `flags` object; now flattened onto the
+ * config root (`...FlagsSchema.shape` in `ConfigSchema`). The deprecated nested
+ * form still parses through `DataJsonSchema`.
+ */
+export declare const FlagsSchema: z.ZodObject<{
+    /** Enable experimental MapLibre GL JS support. */
+    enableExperimentalMaplibre: z.ZodOptional<z.ZodBoolean>;
+    /** Custom `setkiosk` phrase. */
+    customSetKiosk: z.ZodOptional<z.ZodString>;
+    /** Hide booth number badges. */
+    hideBoothBadges: z.ZodOptional<z.ZodBoolean>;
+    /**
+     * Enable live bus/transport routing on the floor plan.
+     *
+     * Disabled by default: most plans have no transit routes, and probing for
+     * them issues an extra HTTP request on every load. Set to `true` only for
+     * plans that actually provide bus routes.
+     */
+    busRoutes: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+//# sourceMappingURL=flags.d.ts.map

package/dist/lib/flags.js

@@ -0,0 +1,22 @@
+import * as z from 'zod';
+/**
+ * Feature flags. Historically a nested `flags` object; now flattened onto the
+ * config root (`...FlagsSchema.shape` in `ConfigSchema`). The deprecated nested
+ * form still parses through `DataJsonSchema`.
+ */
+export const FlagsSchema = z.looseObject({
+    /** Enable experimental MapLibre GL JS support. */
+    enableExperimentalMaplibre: z.boolean().optional(),
+    /** Custom `setkiosk` phrase. */
+    customSetKiosk: z.string().optional(),
+    /** Hide booth number badges. */
+    hideBoothBadges: z.boolean().optional(),
+    /**
+     * Enable live bus/transport routing on the floor plan.
+     *
+     * Disabled by default: most plans have no transit routes, and probing for
+     * them issues an extra HTTP request on every load. Set to `true` only for
+     * plans that actually provide bus routes.
+     */
+    busRoutes: z.boolean().optional(),
+});

package/dist/lib/fp-geo.d.ts

@@ -0,0 +1,95 @@
+import * as z from 'zod';
+/**
+ * `__fpGeo`: the georeferencing block carried in an `fp.svg.js` payload — corner
+ * anchors, map orientation, and overlay images, structured as a
+ * GeoJSON-FeatureCollection extension. The runtime reads `properties.config`,
+ * `properties.style`, and `images` (`data/fpGeo.ts`); the FeatureCollection part
+ * (`type`, `features`) passes through untyped.
+ */
+/** A plan point pinned to a map coordinate — geo-references the drawing. */
+export declare const FpGeoAnchorSchema: z.ZodObject<{
+    lat: z.ZodNumber;
+    lng: z.ZodNumber;
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+}, z.core.$strip>;
+/** `__fpGeo.properties.config`: corner anchors and map orientation. */
+export declare const FpGeoConfigSchema: z.ZodObject<{
+    p0: z.ZodOptional<z.ZodObject<{
+        lat: z.ZodNumber;
+        lng: z.ZodNumber;
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>>;
+    p1: z.ZodOptional<z.ZodObject<{
+        lat: z.ZodNumber;
+        lng: z.ZodNumber;
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>>;
+    p2: z.ZodOptional<z.ZodObject<{
+        lat: z.ZodNumber;
+        lng: z.ZodNumber;
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>>;
+    p3: z.ZodOptional<z.ZodObject<{
+        lat: z.ZodNumber;
+        lng: z.ZodNumber;
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>>;
+    bearing: z.ZodOptional<z.ZodNumber>;
+    snapThreshold: z.ZodOptional<z.ZodNumber>;
+}, z.core.$loose>;
+/** A georeferenced overlay image (`__fpGeo.images[]`). */
+export declare const FpGeoImageSchema: z.ZodObject<{
+    layer: z.ZodString;
+    data: z.ZodString;
+    points: z.ZodArray<z.ZodArray<z.ZodUnknown>>;
+}, z.core.$loose>;
+/** The full `__fpGeo` block. */
+export declare const FpGeoSchema: z.ZodObject<{
+    properties: z.ZodOptional<z.ZodObject<{
+        config: z.ZodOptional<z.ZodObject<{
+            p0: z.ZodOptional<z.ZodObject<{
+                lat: z.ZodNumber;
+                lng: z.ZodNumber;
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+            }, z.core.$strip>>;
+            p1: z.ZodOptional<z.ZodObject<{
+                lat: z.ZodNumber;
+                lng: z.ZodNumber;
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+            }, z.core.$strip>>;
+            p2: z.ZodOptional<z.ZodObject<{
+                lat: z.ZodNumber;
+                lng: z.ZodNumber;
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+            }, z.core.$strip>>;
+            p3: z.ZodOptional<z.ZodObject<{
+                lat: z.ZodNumber;
+                lng: z.ZodNumber;
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+            }, z.core.$strip>>;
+            bearing: z.ZodOptional<z.ZodNumber>;
+            snapThreshold: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>>;
+        mpViewbox: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+        useMaplibre: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$loose>>;
+    images: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        layer: z.ZodString;
+        data: z.ZodString;
+        points: z.ZodArray<z.ZodArray<z.ZodUnknown>>;
+    }, z.core.$loose>>>;
+}, z.core.$loose>;
+export type FpGeoAnchor = z.infer<typeof FpGeoAnchorSchema>;
+export type FpGeoConfig = z.infer<typeof FpGeoConfigSchema>;
+export type FpGeoImage = z.infer<typeof FpGeoImageSchema>;
+export type FpGeo = z.infer<typeof FpGeoSchema>;
+//# sourceMappingURL=fp-geo.d.ts.map