@expofp/schema 0.0.0-experimental.cf063fc

package/dist/lib/fp-svg.js

@@ -0,0 +1,196 @@
+import * as z from 'zod';
+import { FpGeoSchema } from './fp-geo.js';
+import { VenuePayloadSchema } from './venues.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`, `__fpVenues`)
+ * - `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(),
+});
+const FpRectCornerSchema = z.object({ x: z.number(), y: z.number() });
+/** 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(),
+    /**
+     * The rectangle's own corners, clockwise from the top-left — present on
+     * layer viewboxes from converters that emit them. On a turned viewbox these
+     * carry the turn, where `x1`..`y2` stay axis-aligned.
+     */
+    p0: FpRectCornerSchema.optional(),
+    p1: FpRectCornerSchema.optional(),
+    p2: FpRectCornerSchema.optional(),
+    p3: FpRectCornerSchema.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`: the URLs its `<image>`s carry — the `svg-images/…`
+     * hrefs, and the `data-model-3d` 3D models that stand in for them — are asset
+     * paths, made absolute when the payload resolves and 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(),
+    /**
+     * The venue document, carried on the geometry path so it is written by the
+     * same converter run as the `__fpLayers` its layer names join to. Absent on
+     * drawings from a converter that predates it — `loadConfig` then keeps the
+     * `data.js` value (`docs/specs/multi-venue-data-contract.md` §1).
+     */
+    __fpVenues: VenuePayloadSchema.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(),
+});

package/dist/lib/intents.d.ts

@@ -0,0 +1,173 @@
+import * as z from 'zod';
+/**
+ * The list panels the floor plan UI can open by name — the `showList` intent's
+ * argument. Mirrors the keyword deep links (`?bookmarks`, `?sessions`, …).
+ */
+export declare const ListPanelSchema: z.ZodEnum<{
+    bookmarks: "bookmarks";
+    exhibitors: "exhibitors";
+    language: "language";
+    sessions: "sessions";
+    speakers: "speakers";
+    tours: "tours";
+    visited: "visited";
+}>;
+/** Options of the `openPlanner` intent / `FloorPlan.openPlanner` method. */
+export declare const PlannerOptionsSchema: z.ZodObject<{
+    items: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    from: z.ZodOptional<z.ZodString>;
+    fromBookmarks: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+/**
+ * Filters of the `showSessions` intent / `FloorPlan.showSessions` method — the
+ * sessions list's toolbar filters. An omitted field is off.
+ */
+export declare const SessionsFiltersSchema: z.ZodObject<{
+    tracks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    venues: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    date: z.ZodOptional<z.ZodEnum<{
+        past: "past";
+        today: "today";
+        tomorrow: "tomorrow";
+    }>>;
+    time: z.ZodOptional<z.ZodEnum<{
+        afternoon: "afternoon";
+        midday: "midday";
+        morning: "morning";
+    }>>;
+    bookmarked: z.ZodOptional<z.ZodBoolean>;
+    live: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+/**
+ * The visitor position of the `selectCurrentPosition` intent /
+ * `FloorPlan.selectCurrentPosition` method — the floor plan's
+ * `CurrentPosition` interface, field for field.
+ */
+export declare const CurrentPositionSchema: z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    z: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+    angle: z.ZodOptional<z.ZodNumber>;
+    lat: z.ZodOptional<z.ZodNumber>;
+    lng: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * Imperative actions a host requests on the floor plan after it loads — carried
+ * on the config's `intents` field and dispatched by `applyIntents`
+ * (`@expofp/config`) once the plan is ready. A discriminated union on `name`,
+ * each arm mirroring a `FloorPlan` method (same name, `args` matching its
+ * parameters), so adding an intent here extends the host interface
+ * automatically — and the `applyIntents` call site type-checks that every
+ * intent still names a real `FloorPlan` method.
+ */
+export declare const IntentsSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    name: z.ZodLiteral<"selectBooth">;
+    args: z.ZodTuple<[z.ZodString], null>;
+}, z.core.$strip>, z.ZodObject<{
+    name: z.ZodLiteral<"selectExhibitor">;
+    args: z.ZodTuple<[z.ZodString], null>;
+}, z.core.$strip>, z.ZodObject<{
+    name: z.ZodLiteral<"changeLanguage">;
+    args: z.ZodTuple<[z.ZodString], null>;
+}, z.core.$strip>, z.ZodObject<{
+    name: z.ZodLiteral<"selectCategory">;
+    args: z.ZodTuple<[z.ZodString], null>;
+}, z.core.$strip>, z.ZodObject<{
+    name: z.ZodLiteral<"select">;
+    args: z.ZodTuple<[z.ZodString], null>;
+}, z.core.$strip>, z.ZodObject<{
+    name: z.ZodLiteral<"showList">;
+    args: z.ZodTuple<[z.ZodEnum<{
+        bookmarks: "bookmarks";
+        exhibitors: "exhibitors";
+        language: "language";
+        sessions: "sessions";
+        speakers: "speakers";
+        tours: "tours";
+        visited: "visited";
+    }>], null>;
+}, z.core.$strip>, z.ZodObject<{
+    name: z.ZodLiteral<"showSessions">;
+    args: z.ZodTuple<[z.ZodObject<{
+        tracks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        venues: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        date: z.ZodOptional<z.ZodEnum<{
+            past: "past";
+            today: "today";
+            tomorrow: "tomorrow";
+        }>>;
+        time: z.ZodOptional<z.ZodEnum<{
+            afternoon: "afternoon";
+            midday: "midday";
+            morning: "morning";
+        }>>;
+        bookmarked: z.ZodOptional<z.ZodBoolean>;
+        live: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>], null>;
+}, z.core.$strip>, z.ZodObject<{
+    name: z.ZodLiteral<"selectTour">;
+    args: z.ZodTuple<[z.ZodString], null>;
+}, z.core.$strip>, z.ZodObject<{
+    name: z.ZodLiteral<"openPlanner">;
+    args: z.ZodTuple<[z.ZodObject<{
+        items: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        from: z.ZodOptional<z.ZodString>;
+        fromBookmarks: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>], null>;
+}, z.core.$strip>, z.ZodObject<{
+    name: z.ZodLiteral<"startBuildRoute">;
+    args: z.ZodTuple<[], null>;
+}, z.core.$strip>, z.ZodObject<{
+    name: z.ZodLiteral<"setCamera">;
+    args: z.ZodTuple<[z.ZodObject<{
+        x: z.ZodOptional<z.ZodNumber>;
+        y: z.ZodOptional<z.ZodNumber>;
+        lat: z.ZodOptional<z.ZodNumber>;
+        lng: z.ZodOptional<z.ZodNumber>;
+        floor: z.ZodOptional<z.ZodString>;
+        venue: z.ZodOptional<z.ZodString>;
+        bearing: z.ZodOptional<z.ZodNumber>;
+        zoomTime: z.ZodOptional<z.ZodNumber>;
+        pitchTime: z.ZodOptional<z.ZodNumber>;
+        pitchDegrees: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>], null>;
+}, z.core.$strip>, z.ZodObject<{
+    name: z.ZodLiteral<"setVisibility">;
+    args: z.ZodTuple<[z.ZodObject<{
+        controls: z.ZodOptional<z.ZodBoolean>;
+        levels: z.ZodOptional<z.ZodBoolean>;
+        header: z.ZodOptional<z.ZodBoolean>;
+        overlay: z.ZodOptional<z.ZodBoolean>;
+        searchButtons: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>], null>;
+}, z.core.$strip>, z.ZodObject<{
+    name: z.ZodLiteral<"selectRoute">;
+    args: z.ZodTuple<[z.ZodArray<z.ZodString>], null>;
+}, z.core.$strip>, z.ZodObject<{
+    name: z.ZodLiteral<"selectAccessibleRoute">;
+    args: z.ZodTuple<[z.ZodArray<z.ZodString>], null>;
+}, z.core.$strip>, z.ZodObject<{
+    name: z.ZodLiteral<"showPathway">;
+    args: z.ZodTuple<[z.ZodString, z.ZodArray<z.ZodString>], null>;
+}, z.core.$strip>, z.ZodObject<{
+    name: z.ZodLiteral<"selectCurrentPosition">;
+    args: z.ZodTuple<[z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        z: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+        angle: z.ZodOptional<z.ZodNumber>;
+        lat: z.ZodOptional<z.ZodNumber>;
+        lng: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>, z.ZodBoolean, z.ZodOptional<z.ZodNumber>], null>;
+}, z.core.$strip>], "name">;
+/** One imperative floor-plan action — a member of {@link IntentsSchema}. */
+export type Intent = z.infer<typeof IntentsSchema>;
+/** A list panel the `showList` intent can open — a member of {@link ListPanelSchema}. */
+export type ListPanel = z.infer<typeof ListPanelSchema>;
+/** Options of the `openPlanner` intent — see {@link PlannerOptionsSchema}. */
+export type PlannerOptions = z.infer<typeof PlannerOptionsSchema>;
+/** Filters of the `showSessions` intent — see {@link SessionsFiltersSchema}. */
+export type SessionsFilters = z.infer<typeof SessionsFiltersSchema>;
+/** The `selectCurrentPosition` point — see {@link CurrentPositionSchema}. */
+export type CurrentPosition = z.infer<typeof CurrentPositionSchema>;
+//# sourceMappingURL=intents.d.ts.map

package/dist/lib/intents.js

@@ -0,0 +1,153 @@
+import * as z from 'zod';
+import { CameraSchema } from './camera.js';
+import { VisibilitySchema } from './visibility.js';
+/**
+ * The list panels the floor plan UI can open by name — the `showList` intent's
+ * argument. Mirrors the keyword deep links (`?bookmarks`, `?sessions`, …).
+ */
+export const ListPanelSchema = z.enum([
+    'bookmarks',
+    'visited',
+    'sessions',
+    'exhibitors',
+    'speakers',
+    'tours',
+    'language',
+]);
+/** Options of the `openPlanner` intent / `FloorPlan.openPlanner` method. */
+export const PlannerOptionsSchema = z.object({
+    /** Entity slugs to plan a route through (ignored with `fromBookmarks`). */
+    items: z.array(z.string()).optional(),
+    /** Booth to start from. */
+    from: z.string().optional(),
+    /** Fill the planner from the visitor's bookmarks instead of `items`. */
+    fromBookmarks: z.boolean().optional(),
+});
+/**
+ * Filters of the `showSessions` intent / `FloorPlan.showSessions` method — the
+ * sessions list's toolbar filters. An omitted field is off.
+ */
+export const SessionsFiltersSchema = z.object({
+    /** Tracks to show: names, external ids or ids. */
+    tracks: z.array(z.string()).optional(),
+    /** Venues (the booths sessions take place in) to show: names, external ids or ids. */
+    venues: z.array(z.string()).optional(),
+    /** Day to show. */
+    date: z.enum(['today', 'tomorrow', 'past']).optional(),
+    /** Time of day to show; it narrows the list only together with `date: 'today'`. */
+    time: z.enum(['morning', 'midday', 'afternoon']).optional(),
+    /** Only the visitor's bookmarked sessions. */
+    bookmarked: z.boolean().optional(),
+    /** Only the sessions happening now. */
+    live: z.boolean().optional(),
+});
+/**
+ * The visitor position of the `selectCurrentPosition` intent /
+ * `FloorPlan.selectCurrentPosition` method — the floor plan's
+ * `CurrentPosition` interface, field for field.
+ */
+export const CurrentPositionSchema = z.object({
+    /** Plan x coordinate. */
+    x: z.number(),
+    /** Plan y coordinate. */
+    y: z.number(),
+    /** Floor: level name or index. */
+    z: z.union([z.number(), z.string()]).optional(),
+    /** Heading in degrees. */
+    angle: z.number().optional(),
+    /** GPS latitude (with `lng`, an alternative fix to `x`/`y`). */
+    lat: z.number().optional(),
+    /** GPS longitude. */
+    lng: z.number().optional(),
+});
+/**
+ * Imperative actions a host requests on the floor plan after it loads — carried
+ * on the config's `intents` field and dispatched by `applyIntents`
+ * (`@expofp/config`) once the plan is ready. A discriminated union on `name`,
+ * each arm mirroring a `FloorPlan` method (same name, `args` matching its
+ * parameters), so adding an intent here extends the host interface
+ * automatically — and the `applyIntents` call site type-checks that every
+ * intent still names a real `FloorPlan` method.
+ */
+export const IntentsSchema = z.discriminatedUnion('name', [
+    z.object({
+        name: z.literal('selectBooth'),
+        args: z.tuple([z.string()]),
+    }),
+    z.object({
+        name: z.literal('selectExhibitor'),
+        args: z.tuple([z.string()]),
+    }),
+    z.object({
+        name: z.literal('changeLanguage'),
+        args: z.tuple([z.string()]),
+    }),
+    z.object({
+        name: z.literal('selectCategory'),
+        args: z.tuple([z.string()]),
+    }),
+    z.object({
+        // The universal deep-link resolver: whatever the slug or external id names
+        // (booth → session → exhibitor → category → speaker), else open search.
+        name: z.literal('select'),
+        args: z.tuple([z.string()]),
+    }),
+    z.object({
+        name: z.literal('showList'),
+        args: z.tuple([ListPanelSchema]),
+    }),
+    z.object({
+        name: z.literal('showSessions'),
+        args: z.tuple([SessionsFiltersSchema]),
+    }),
+    z.object({
+        name: z.literal('selectTour'),
+        args: z.tuple([z.string()]),
+    }),
+    z.object({
+        name: z.literal('openPlanner'),
+        args: z.tuple([PlannerOptionsSchema]),
+    }),
+    z.object({
+        name: z.literal('startBuildRoute'),
+        args: z.tuple([]),
+    }),
+    z.object({
+        name: z.literal('setCamera'),
+        args: z.tuple([CameraSchema]),
+    }),
+    z.object({
+        name: z.literal('setVisibility'),
+        // an empty visibility request is meaningless and the public method raises
+        // an SDK error on it (then falls through to a show-everything reset) — a
+        // typo'd shortcut (`?setVisibility[bogus]=1` coerces to `{}`) must degrade
+        // to a dropped intent instead: a shared link must not toast
+        args: z.tuple([VisibilitySchema.refine((v) => Object.keys(v).length > 0)]),
+    }),
+    z.object({
+        // Ordered waypoints — entity names/slugs, first to last; two entries are
+        // the classic from→to, extra ones are stops in between. Min 2: the method
+        // rejects a route without both a start and a destination (the FROM-less
+        // kiosk-anchor route stays a legacy-grammar capability); `CurrentPosition`
+        // waypoints stay API-only.
+        name: z.literal('selectRoute'),
+        args: z.tuple([z.array(z.string()).min(2)]),
+    }),
+    z.object({
+        // `selectRoute` restricted to accessible segments only.
+        name: z.literal('selectAccessibleRoute'),
+        args: z.tuple([z.array(z.string()).min(2)]),
+    }),
+    z.object({
+        // A pathway to show, plus external ids of booths/exhibitors to highlight
+        // along it (`[]` = just the pathway).
+        name: z.literal('showPathway'),
+        args: z.tuple([z.string(), z.array(z.string())]),
+    }),
+    z.object({
+        // Where the visitor is, whether to center the view there, and optionally
+        // the marker icon variant.
+        name: z.literal('selectCurrentPosition'),
+        args: z.tuple([CurrentPositionSchema, z.boolean(), z.number().optional()]),
+    }),
+]);

package/dist/lib/journey.d.ts

@@ -0,0 +1,27 @@
+import * as z from 'zod';
+/**
+ * The journey deep link — the `config.journey` node, and the query a scanned
+ * kiosk QR or a desktop "continue on your phone" link arrives as
+ * (`?journey[to]=A-12&journey[from]=B-30`).
+ *
+ * IDENTIFIERS ONLY, on purpose: a journey is recomputed from live plan data
+ * when the link opens, never restored from it. A link that carried legs,
+ * coordinates or a provider URL would hand the phone whatever the plan looked
+ * like when the code was printed — the QR beside a kiosk outlives more than one
+ * plan edit. Everything a journey needs beyond these two names (the venues,
+ * their anchors, the provider, the distance) the receiving device already has,
+ * fresher.
+ *
+ * The origin is optional because two of its three sources are the device's own:
+ * a live position and a kiosk anchor travel as themselves (the kiosk anchor
+ * through the legacy `kiosk_*` params the QR-share pattern already smuggles),
+ * leaving `from` to name a picked from-booth — the one origin that is an
+ * authored place rather than a device.
+ */
+export declare const JourneyLinkSchema: z.ZodObject<{
+    to: z.ZodString;
+    from: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/** A journey deep link's payload — see {@link JourneyLinkSchema}. */
+export type JourneyLink = z.infer<typeof JourneyLinkSchema>;
+//# sourceMappingURL=journey.d.ts.map

package/dist/lib/journey.js

@@ -0,0 +1,26 @@
+import * as z from 'zod';
+/**
+ * The journey deep link — the `config.journey` node, and the query a scanned
+ * kiosk QR or a desktop "continue on your phone" link arrives as
+ * (`?journey[to]=A-12&journey[from]=B-30`).
+ *
+ * IDENTIFIERS ONLY, on purpose: a journey is recomputed from live plan data
+ * when the link opens, never restored from it. A link that carried legs,
+ * coordinates or a provider URL would hand the phone whatever the plan looked
+ * like when the code was printed — the QR beside a kiosk outlives more than one
+ * plan edit. Everything a journey needs beyond these two names (the venues,
+ * their anchors, the provider, the distance) the receiving device already has,
+ * fresher.
+ *
+ * The origin is optional because two of its three sources are the device's own:
+ * a live position and a kiosk anchor travel as themselves (the kiosk anchor
+ * through the legacy `kiosk_*` params the QR-share pattern already smuggles),
+ * leaving `from` to name a picked from-booth — the one origin that is an
+ * authored place rather than a device.
+ */
+export const JourneyLinkSchema = z.object({
+    /** The destination entity — a booth or exhibitor slug / external id. */
+    to: z.string().min(1),
+    /** The origin entity, when the journey started from a picked from-booth. */
+    from: z.string().min(1).optional(),
+});

package/dist/lib/kiosk.d.ts

@@ -0,0 +1,39 @@
+import * as z from 'zod';
+/**
+ * The kiosk anchor — the `config.kiosk` node: where the physical 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 persists to localStorage
+ * and wins over the config; the `localStorage['kiosk']='0'` device switch
+ * disables both). `?kiosk=1/0` keeps toggling kiosk MODE — the mode and the
+ * anchor are independent inputs.
+ *
+ * The legacy `kiosk_x/y/z` params are a narrower, per-navigation channel for
+ * one purpose: a kiosk's route QR code hands the scanning phone the anchor
+ * POSITION so the route's missing starting point resolves there. The framing
+ * fields below travel only in this node, never through those params, and the
+ * params put the scanning device in no kiosk mode of its own.
+ */
+export declare const KioskSchema: z.ZodObject<{
+    x: z.ZodOptional<z.ZodNumber>;
+    y: z.ZodOptional<z.ZodNumber>;
+    z: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+    heading: z.ZodOptional<z.ZodNumber>;
+    lat: z.ZodOptional<z.ZodNumber>;
+    lng: z.ZodOptional<z.ZodNumber>;
+    iconSizePercent: z.ZodOptional<z.ZodNumber>;
+    uiScale: z.ZodOptional<z.ZodNumber>;
+    mapRollDegrees: z.ZodOptional<z.ZodNumber>;
+    mapInitialPtScale: z.ZodOptional<z.ZodNumber>;
+    mapPtScale: z.ZodOptional<z.ZodNumber>;
+    mapCenterX: z.ZodOptional<z.ZodNumber>;
+    mapCenterY: z.ZodOptional<z.ZodNumber>;
+    mapPitch: z.ZodOptional<z.ZodNumber>;
+    mapCenterLng: z.ZodOptional<z.ZodNumber>;
+    mapCenterLat: z.ZodOptional<z.ZodNumber>;
+    mapZoom: z.ZodOptional<z.ZodNumber>;
+    mapBearingDegrees: z.ZodOptional<z.ZodNumber>;
+    mapPitchDegrees: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export interface Kiosk extends z.infer<typeof KioskSchema> {
+}
+//# sourceMappingURL=kiosk.d.ts.map