@expofp/schema 3.11.12

package/dist/lib/fp-geo.js

@@ -0,0 +1,41 @@
+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 const FpGeoAnchorSchema = z.object({
+    lat: z.number(),
+    lng: z.number(),
+    x: z.number(),
+    y: z.number(),
+});
+/** `__fpGeo.properties.config`: corner anchors and map orientation. */
+export const FpGeoConfigSchema = z.looseObject({
+    p0: FpGeoAnchorSchema.optional(),
+    p1: FpGeoAnchorSchema.optional(),
+    p2: FpGeoAnchorSchema.optional(),
+    p3: FpGeoAnchorSchema.optional(),
+    bearing: z.number().optional(),
+    snapThreshold: z.number().optional(),
+});
+/** A georeferenced overlay image (`__fpGeo.images[]`). */
+export const FpGeoImageSchema = z.looseObject({
+    layer: z.string(),
+    data: z.string(),
+    points: z.array(z.array(z.unknown())),
+});
+/** The full `__fpGeo` block. */
+export const FpGeoSchema = z.looseObject({
+    properties: z
+        .looseObject({
+        config: FpGeoConfigSchema.optional(),
+        mpViewbox: z.array(z.number()).optional(),
+        useMaplibre: z.boolean().optional(),
+    })
+        .optional(),
+    images: z.array(FpGeoImageSchema).optional(),
+});

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

@@ -0,0 +1,301 @@
+import * as z from 'zod';
+/**
+ * One `__fpPaths` entry: a shape outline triangulated for the WebGL renderer,
+ * indexed by the SVG paths' `data-index`. Matches the renderer's `MeshType`
+ * (`renderer/engine-core/types.ts`) — whose `positions` are 3D vertices, the
+ * shape the V2 converter emits (see {@link PositionSchema}).
+ */
+export declare const FpPathSchema: z.ZodObject<{
+    positions: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodOptional<z.ZodNumber>], null>>;
+    cells: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+}, z.core.$strip>;
+/**
+ * `__fpSettings`: renderer style overrides, deep-merged into the `FpSettings`
+ * singleton (`tools/settings.ts`).
+ */
+export declare const FpSettingsSchema: z.ZodObject<{
+    boothLabelColor: z.ZodOptional<z.ZodString>;
+    boothBorderColor: z.ZodOptional<z.ZodString>;
+    backgroundColor: z.ZodOptional<z.ZodString>;
+    boothBorderWidth: z.ZodOptional<z.ZodNumber>;
+    heatmapColors: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    maxZoom: z.ZodOptional<z.ZodNumber>;
+    /**
+     * Converter format version (`"5.0"`); gates v5+ runtime features. Distinct
+     * from the numeric `__fpVersion`.
+     */
+    fpVer: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+/** `__fpStat`: converter output stats. `dataSize` is in bytes. */
+export declare const FpStatSchema: z.ZodObject<{
+    dataSize: z.ZodOptional<z.ZodNumber>;
+}, z.core.$loose>;
+/**
+ * `__viewbox`: the author-drawn initial view rectangle — the fit-to-screen
+ * reference, taking precedence over the drawing's own bounds.
+ */
+export declare const FpViewboxSchema: z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+    angle: z.ZodOptional<z.ZodNumber>;
+}, z.core.$loose>;
+/** A min/max rectangle in the legacy `core/Rect` shape. */
+export declare const FpRectSchema: z.ZodObject<{
+    x1: z.ZodNumber;
+    y1: z.ZodNumber;
+    x2: z.ZodNumber;
+    y2: z.ZodNumber;
+    /** Rotation — present on layer viewboxes. */
+    angle: z.ZodOptional<z.ZodNumber>;
+}, z.core.$loose>;
+/**
+ * One `__fpLayers` entry (consumed by `store/init/init-layers.ts`). `name` also
+ * derives the layer's file and global names: `fp.svg.<name>.js`, `__fp<name>`,
+ * `__fpPaths<name>`. `mode` is the numeric `LayerMode` enum (0 Unset, 1
+ * AlwaysVisible, 2 AlwaysHidden, 3 TurnedOn, 4 TurnedOff — `store/LayerStore.ts`).
+ */
+export declare const FpLayerSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    frozen: z.ZodOptional<z.ZodBoolean>;
+    mode: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    rect: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        x1: z.ZodNumber;
+        y1: z.ZodNumber;
+        x2: z.ZodNumber;
+        y2: z.ZodNumber;
+        /** Rotation — present on layer viewboxes. */
+        angle: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>>>;
+    viewbox: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        x1: z.ZodNumber;
+        y1: z.ZodNumber;
+        x2: z.ZodNumber;
+        y2: z.ZodNumber;
+        /** Rotation — present on layer viewboxes. */
+        angle: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>>>;
+    floorIndex: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$loose>;
+/**
+ * The evaluated `fp.svg.<layerName>.js` payload — one drawing layer, loaded on
+ * demand when a multi-floor plan shows a layer whose paths are not present yet
+ * (`components/Map/drawing/config/config-load-layer.ts`).
+ */
+export declare const FpSvgLayerJsSchema: z.ZodObject<{
+    /**
+     * The layer's SVG document (newer layer files emit it only as the
+     * `__fp<layerName>` alias; the loader folds it back here — see the module
+     * doc). Tagged `svgAsset`: its `<image>` hrefs are `svg-images/…` asset
+     * paths — made absolute when the payload resolves, localized when an
+     * offline copy is serialized.
+     */
+    __fp: z.ZodOptional<z.ZodString>;
+    /** Triangulated meshes by `data-index` (newer files: folded from the alias). */
+    __fpPaths: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        positions: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodOptional<z.ZodNumber>], null>>;
+        cells: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    }, z.core.$strip>>>;
+    __fpGeo: z.ZodOptional<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>>;
+    __fpSettings: z.ZodOptional<z.ZodObject<{
+        boothLabelColor: z.ZodOptional<z.ZodString>;
+        boothBorderColor: z.ZodOptional<z.ZodString>;
+        backgroundColor: z.ZodOptional<z.ZodString>;
+        boothBorderWidth: z.ZodOptional<z.ZodNumber>;
+        heatmapColors: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        maxZoom: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Converter format version (`"5.0"`); gates v5+ runtime features. Distinct
+         * from the numeric `__fpVersion`.
+         */
+        fpVer: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+    __fpStat: z.ZodOptional<z.ZodObject<{
+        dataSize: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>>;
+    /** Numeric data-format version (e.g. `6`). Distinct from `fpVer`. */
+    __fpVersion: z.ZodOptional<z.ZodNumber>;
+}, z.core.$loose>;
+/**
+ * A `$ref` to one layer's `fp.svg.<layerName>.js`. The layer's data is not
+ * loaded eagerly: `resolve()` (`@expofp/resolve`) evaluates a `.js` ref on
+ * demand and returns its assigned globals as JSON — a {@link FpSvgLayerJsSchema}
+ * payload.
+ */
+export declare const FpSvgLayerJsRefSchema: z.ZodObject<{
+    $ref: z.ZodString;
+}, z.core.$strip>;
+/**
+ * The evaluated `fp.svg.js` payload — the default layer's drawing plus plan-wide
+ * metadata.
+ */
+export declare const FpSvgJsSchema: z.ZodObject<{
+    /** Plan is still generating server-side: stub payload, poll again later. */
+    __fpPending: z.ZodOptional<z.ZodBoolean>;
+    __viewbox: z.ZodOptional<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+        angle: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>>;
+    __fpLayers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        frozen: z.ZodOptional<z.ZodBoolean>;
+        mode: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        rect: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            x1: z.ZodNumber;
+            y1: z.ZodNumber;
+            x2: z.ZodNumber;
+            y2: z.ZodNumber;
+            /** Rotation — present on layer viewboxes. */
+            angle: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>>>;
+        viewbox: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            x1: z.ZodNumber;
+            y1: z.ZodNumber;
+            x2: z.ZodNumber;
+            y2: z.ZodNumber;
+            /** Rotation — present on layer viewboxes. */
+            angle: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>>>;
+        floorIndex: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    }, z.core.$loose>>>;
+    /**
+     * Numeric `LayersMode` enum (0 Default/single-floor, 1 Separated, 2
+     * Radio/multi-floor, 3 CheckBox — `store/LayerStore.ts`).
+     */
+    __fpLayersMode: z.ZodOptional<z.ZodNumber>;
+    /** `name` of the layer whose drawing this file carries. */
+    __fpDefaultLayer: z.ZodOptional<z.ZodString>;
+    /**
+     * The layer's SVG document (newer layer files emit it only as the
+     * `__fp<layerName>` alias; the loader folds it back here — see the module
+     * doc). Tagged `svgAsset`: its `<image>` hrefs are `svg-images/…` asset
+     * paths — made absolute when the payload resolves, localized when an
+     * offline copy is serialized.
+     */
+    __fp: z.ZodOptional<z.ZodString>;
+    /** Triangulated meshes by `data-index` (newer files: folded from the alias). */
+    __fpPaths: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        positions: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodOptional<z.ZodNumber>], null>>;
+        cells: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    }, z.core.$strip>>>;
+    __fpGeo: z.ZodOptional<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>>;
+    __fpSettings: z.ZodOptional<z.ZodObject<{
+        boothLabelColor: z.ZodOptional<z.ZodString>;
+        boothBorderColor: z.ZodOptional<z.ZodString>;
+        backgroundColor: z.ZodOptional<z.ZodString>;
+        boothBorderWidth: z.ZodOptional<z.ZodNumber>;
+        heatmapColors: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        maxZoom: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Converter format version (`"5.0"`); gates v5+ runtime features. Distinct
+         * from the numeric `__fpVersion`.
+         */
+        fpVer: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+    __fpStat: z.ZodOptional<z.ZodObject<{
+        dataSize: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>>;
+    /** Numeric data-format version (e.g. `6`). Distinct from `fpVer`. */
+    __fpVersion: z.ZodOptional<z.ZodNumber>;
+}, z.core.$loose>;
+/**
+ * A `$ref` to the expo's `fp.svg.js` — resolves to a {@link FpSvgJsSchema}
+ * payload. Set explicitly (e.g. by an offline copy pointing at a resolved
+ * `fp.svg.json`) to override the `<legacyDataUrlBase>fp.svg.js` derivation.
+ */
+export declare const FpSvgJsRefSchema: z.ZodObject<{
+    $ref: z.ZodString;
+}, z.core.$strip>;
+export type FpPath = z.infer<typeof FpPathSchema>;
+export type FpSettings = z.infer<typeof FpSettingsSchema>;
+export type FpStat = z.infer<typeof FpStatSchema>;
+export type FpViewbox = z.infer<typeof FpViewboxSchema>;
+export type FpRect = z.infer<typeof FpRectSchema>;
+export type FpLayer = z.infer<typeof FpLayerSchema>;
+export type FpSvgLayerJs = z.infer<typeof FpSvgLayerJsSchema>;
+export type FpSvgLayerJsRef = z.infer<typeof FpSvgLayerJsRefSchema>;
+export type FpSvgJs = z.infer<typeof FpSvgJsSchema>;
+export type FpSvgJsRef = z.infer<typeof FpSvgJsRefSchema>;
+//# sourceMappingURL=fp-svg.d.ts.map

package/dist/lib/fp-svg.js

@@ -0,0 +1,177 @@
+import * as z from 'zod';
+import { FpGeoSchema } from './fp-geo.js';
+/**
+ * Schemas for the legacy `fp.svg.js` drawing payloads served next to `data.js`
+ * under `legacyDataUrlBase`:
+ *
+ * - `fp.svg.js` — {@link FpSvgJsSchema}: the default layer's drawing plus
+ *   plan-wide metadata (`__fp`, `__fpPaths`, `__fpGeo`, `__fpSettings`,
+ *   `__fpStat`, `__fpVersion`, `__viewbox`, `__fpLayers`, `__fpLayersMode`,
+ *   `__fpDefaultLayer`)
+ * - `fp.svg.<layerName>.js` — {@link FpSvgLayerJsSchema}: one additional drawing
+ *   layer (`__fp`, `__fpPaths`, and per-file copies of the shared globals)
+ *
+ * The `.js` files are classic browser scripts that assign `window` globals, not
+ * JSON documents. `importJsAsJson`/`evalJsToJson` (`@expofp/utils`) evaluate one
+ * and return its assigned globals as a plain object — one key per global — and
+ * `resolve` (`@expofp/resolve`) routes any `.js` `$ref` through that path. The
+ * schemas below describe those evaluated payloads; see
+ * `packages/utils/src/lib/import-js-as-json.spec.ts` for a canonical sample.
+ *
+ * The drawing globals come in two converter generations. Older files
+ * chain-assign layer-suffixed aliases (`window['__fp1'] = window['__fp'] = …`,
+ * `window['__fpPaths1'] = window['__fpPaths'] = …`), so a payload carries each
+ * drawing global under both names. Newer converters emit ONLY the suffixed
+ * globals in layer files (`window['__fpBooth'] = …` — chaining had every layer
+ * script clobber the shared `window.__fp`), so a raw layer payload may lack
+ * the plain keys entirely; `normalizeFpSvgLayerAliases` (`@expofp/config`)
+ * folds the alias onto them when the payload resolves, before the `svgAsset`
+ * href rewrite — consumers only ever see the plain keys populated. The
+ * payload schemas are loose objects: the dynamically-named `__fp<layerName>` /
+ * `__fpPaths<layerName>` keys pass through unvalidated.
+ *
+ * Every field is optional. The files are emitted by several generations of the
+ * platform converter, and a still-generating plan serves a stub that only sets
+ * `__fpPending`. Field shapes mirror how the floorplan runtime consumes the same
+ * payloads off the config (`getConfig().fpSvgJs` / `getFpSvg()` / `getFpPaths()`):
+ * `data/svg.ts` (`__fp*`, `__viewbox`), `store/init/init-layers.ts` (`__fpLayers*`),
+ * and `tools/settings.ts` (`__fpSettings`).
+ */
+/**
+ * A mesh vertex: `[x, y]` (legacy converter) or `[x, y, z]` (V2 converter, which
+ * emits a always-zero `z`). The runtime reads only `x`/`y` (`data/svg.ts`).
+ */
+const PositionSchema = z.tuple([z.number(), z.number(), z.number().optional()]);
+/** A triangle as three indices into a `positions` array. */
+const TriangleSchema = z.tuple([z.number(), z.number(), z.number()]);
+/**
+ * One `__fpPaths` entry: a shape outline triangulated for the WebGL renderer,
+ * indexed by the SVG paths' `data-index`. Matches the renderer's `MeshType`
+ * (`renderer/engine-core/types.ts`) — whose `positions` are 3D vertices, the
+ * shape the V2 converter emits (see {@link PositionSchema}).
+ */
+export const FpPathSchema = z.object({
+    positions: z.array(PositionSchema),
+    cells: z.array(TriangleSchema),
+});
+/**
+ * `__fpSettings`: renderer style overrides, deep-merged into the `FpSettings`
+ * singleton (`tools/settings.ts`).
+ */
+export const FpSettingsSchema = z.looseObject({
+    boothLabelColor: z.string().optional(),
+    boothBorderColor: z.string().optional(),
+    backgroundColor: z.string().optional(),
+    boothBorderWidth: z.number().optional(),
+    heatmapColors: z.array(z.string()).optional(),
+    maxZoom: z.number().optional(),
+    /**
+     * Converter format version (`"5.0"`); gates v5+ runtime features. Distinct
+     * from the numeric `__fpVersion`.
+     */
+    fpVer: z.string().optional(),
+});
+/** `__fpStat`: converter output stats. `dataSize` is in bytes. */
+export const FpStatSchema = z.looseObject({
+    dataSize: z.number().optional(),
+});
+/**
+ * `__viewbox`: the author-drawn initial view rectangle — the fit-to-screen
+ * reference, taking precedence over the drawing's own bounds.
+ */
+export const FpViewboxSchema = z.looseObject({
+    x: z.number(),
+    y: z.number(),
+    width: z.number(),
+    height: z.number(),
+    angle: z.number().optional(),
+});
+/** A min/max rectangle in the legacy `core/Rect` shape. */
+export const FpRectSchema = z.looseObject({
+    x1: z.number(),
+    y1: z.number(),
+    x2: z.number(),
+    y2: z.number(),
+    /** Rotation — present on layer viewboxes. */
+    angle: z.number().optional(),
+});
+/**
+ * One `__fpLayers` entry (consumed by `store/init/init-layers.ts`). `name` also
+ * derives the layer's file and global names: `fp.svg.<name>.js`, `__fp<name>`,
+ * `__fpPaths<name>`. `mode` is the numeric `LayerMode` enum (0 Unset, 1
+ * AlwaysVisible, 2 AlwaysHidden, 3 TurnedOn, 4 TurnedOff — `store/LayerStore.ts`).
+ */
+export const FpLayerSchema = z.looseObject({
+    name: z.string(),
+    description: z.string().optional(),
+    frozen: z.boolean().optional(),
+    mode: z.number().nullish(),
+    rect: FpRectSchema.nullish(),
+    viewbox: FpRectSchema.nullish(),
+    floorIndex: z.number().nullish(),
+});
+/** Globals common to `fp.svg.js` and every `fp.svg.<layerName>.js`. */
+const fpSvgCommonShape = {
+    /**
+     * The layer's SVG document (newer layer files emit it only as the
+     * `__fp<layerName>` alias; the loader folds it back here — see the module
+     * doc). Tagged `svgAsset`: its `<image>` hrefs are `svg-images/…` asset
+     * paths — made absolute when the payload resolves, localized when an
+     * offline copy is serialized.
+     */
+    __fp: z.string().optional().meta({ svgAsset: true }),
+    /** Triangulated meshes by `data-index` (newer files: folded from the alias). */
+    __fpPaths: z.array(FpPathSchema).optional(),
+    __fpGeo: FpGeoSchema.optional(),
+    __fpSettings: FpSettingsSchema.optional(),
+    __fpStat: FpStatSchema.optional(),
+    /** Numeric data-format version (e.g. `6`). Distinct from `fpVer`. */
+    __fpVersion: z.number().optional(),
+};
+/**
+ * The evaluated `fp.svg.<layerName>.js` payload — one drawing layer, loaded on
+ * demand when a multi-floor plan shows a layer whose paths are not present yet
+ * (`components/Map/drawing/config/config-load-layer.ts`).
+ */
+export const FpSvgLayerJsSchema = z.looseObject({
+    ...fpSvgCommonShape,
+});
+/**
+ * A `$ref` to one layer's `fp.svg.<layerName>.js`. The layer's data is not
+ * loaded eagerly: `resolve()` (`@expofp/resolve`) evaluates a `.js` ref on
+ * demand and returns its assigned globals as JSON — a {@link FpSvgLayerJsSchema}
+ * payload.
+ */
+export const FpSvgLayerJsRefSchema = z
+    .object({
+    $ref: z.string(),
+})
+    .meta({ refSchema: FpSvgLayerJsSchema });
+/**
+ * The evaluated `fp.svg.js` payload — the default layer's drawing plus plan-wide
+ * metadata.
+ */
+export const FpSvgJsSchema = z.looseObject({
+    ...fpSvgCommonShape,
+    /** Plan is still generating server-side: stub payload, poll again later. */
+    __fpPending: z.boolean().optional(),
+    __viewbox: FpViewboxSchema.optional(),
+    __fpLayers: z.array(FpLayerSchema).optional(),
+    /**
+     * Numeric `LayersMode` enum (0 Default/single-floor, 1 Separated, 2
+     * Radio/multi-floor, 3 CheckBox — `store/LayerStore.ts`).
+     */
+    __fpLayersMode: z.number().optional(),
+    /** `name` of the layer whose drawing this file carries. */
+    __fpDefaultLayer: z.string().optional(),
+});
+/**
+ * A `$ref` to the expo's `fp.svg.js` — resolves to a {@link FpSvgJsSchema}
+ * payload. Set explicitly (e.g. by an offline copy pointing at a resolved
+ * `fp.svg.json`) to override the `<legacyDataUrlBase>fp.svg.js` derivation.
+ */
+export const FpSvgJsRefSchema = z
+    .object({
+    $ref: z.string(),
+})
+    .meta({ refSchema: FpSvgJsSchema });

package/dist/lib/heatmap.d.ts

@@ -0,0 +1,23 @@
+import * as z from 'zod';
+/**
+ * The heatmap-mode request — the `config.heatmap` node. An empty object (the
+ * default) means no heatmap; a non-empty node engages the mode unless switched
+ * off with an explicit `enabled: false` — presence implies intent, so
+ * `?heatmap[variant]=yah` alone is enough, and `?heatmap[enabled]=false` can
+ * veto a manifest-set node (config layers replace the node wholesale).
+ *
+ * Heatmap mode freezes the page URL for its whole session (the legacy
+ * contract). The request's access token (`?t=`) is deliberately NOT a field
+ * here — it is request material the data loader reads raw from the query.
+ */
+export declare const HeatmapSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    variant: z.ZodOptional<z.ZodEnum<{
+        booths: "booths";
+        yah: "yah";
+    }>>;
+    kiosk: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export interface Heatmap extends z.infer<typeof HeatmapSchema> {
+}
+//# sourceMappingURL=heatmap.d.ts.map

package/dist/lib/heatmap.js

@@ -0,0 +1,24 @@
+import * as z from 'zod';
+/**
+ * The heatmap-mode request — the `config.heatmap` node. An empty object (the
+ * default) means no heatmap; a non-empty node engages the mode unless switched
+ * off with an explicit `enabled: false` — presence implies intent, so
+ * `?heatmap[variant]=yah` alone is enough, and `?heatmap[enabled]=false` can
+ * veto a manifest-set node (config layers replace the node wholesale).
+ *
+ * Heatmap mode freezes the page URL for its whole session (the legacy
+ * contract). The request's access token (`?t=`) is deliberately NOT a field
+ * here — it is request material the data loader reads raw from the query.
+ */
+export const HeatmapSchema = z.object({
+    /** Engage the heatmap explicitly; `false` vetoes an otherwise non-empty node. */
+    enabled: z.boolean().optional(),
+    /**
+     * The dataset shown: `booths` (the default) — booth/exhibitor view stats;
+     * `yah` — "You are here" QR-code scan counts, with a stripped-down
+     * monochrome presentation.
+     */
+    variant: z.enum(['booths', 'yah']).optional(),
+    /** Narrow the `yah` variant to kiosk positions (ignored for `booths`). */
+    kiosk: z.boolean().optional(),
+});