venue-js 1.6.0 → 1.7.0

package/dist/data/index.js

@@ -32,6 +32,7 @@ __export(data_exports, {
   ALL_FEATURE_TYPES: () => ALL_FEATURE_TYPES,
   DEFAULT_BASE_URL: () => DEFAULT_BASE_URL,
   GEOJSON_FEATURE_TYPES: () => GEOJSON_FEATURE_TYPES,
+  ID_PREFIX_TO_FEATURE_TYPE: () => ID_PREFIX_TO_FEATURE_TYPE,
   IMDF_FEATURE_TYPES: () => IMDF_FEATURE_TYPES,
   IMDF_UNIT_CATEGORIES: () => IMDF_UNIT_CATEGORIES,
   NONIMDF_FEATURE_TYPES: () => NONIMDF_FEATURE_TYPES,
@@ -58,6 +59,7 @@ __export(data_exports, {
   getDataClient: () => getDataClient,
   getInstructionText: () => getInstructionText,
   getNavigateClient: () => getNavigateClient,
+  getPointOnFeature: () => getPointOnFeature,
   getSearchClient: () => getSearchClient,
   getTurn: () => getTurn,
   matchFilter: () => matchFilter,
@@ -178,6 +180,9 @@ var ALL_FEATURE_TYPES = [
   "sponsored-content",
   "element"
 ];
+var ID_PREFIX_TO_FEATURE_TYPE = {
+  sponsored: "sponsored-content"
+};
 var defaultFeatureQueryOptionsMap = {
   // IMDF
   address: {},
@@ -241,20 +246,143 @@ function matchFilters(item, filters) {
 }
 
 // src/data/utils/findContaining.ts
-var import_point_on_feature = __toESM(require("@turf/point-on-feature"));
 var import_boolean_point_in_polygon = require("@turf/boolean-point-in-polygon");
-var findContainingUnit = (poi, units) => {
-  const unit = units.find(
-    (unit2) => {
-      try {
-        return unit2.properties.level_id === poi.properties.level_id && (0, import_boolean_point_in_polygon.booleanPointInPolygon)((0, import_point_on_feature.default)(poi), unit2);
-      } catch (e) {
-        console.log(`Cannot find containing unit of (${poi.id}):`, e.message);
-        return false;
+var import_intersect = require("@turf/intersect");
+
+// node_modules/@turf/helpers/dist/esm/index.js
+var earthRadius = 63710088e-1;
+var factors = {
+  centimeters: earthRadius * 100,
+  centimetres: earthRadius * 100,
+  degrees: 360 / (2 * Math.PI),
+  feet: earthRadius * 3.28084,
+  inches: earthRadius * 39.37,
+  kilometers: earthRadius / 1e3,
+  kilometres: earthRadius / 1e3,
+  meters: earthRadius,
+  metres: earthRadius,
+  miles: earthRadius / 1609.344,
+  millimeters: earthRadius * 1e3,
+  millimetres: earthRadius * 1e3,
+  nauticalmiles: earthRadius / 1852,
+  radians: 1,
+  yards: earthRadius * 1.0936
+};
+function feature(geom, properties, options = {}) {
+  const feat = { type: "Feature" };
+  if (options.id === 0 || options.id) {
+    feat.id = options.id;
+  }
+  if (options.bbox) {
+    feat.bbox = options.bbox;
+  }
+  feat.properties = properties || {};
+  feat.geometry = geom;
+  return feat;
+}
+function point(coordinates, properties, options = {}) {
+  if (!coordinates) {
+    throw new Error("coordinates is required");
+  }
+  if (!Array.isArray(coordinates)) {
+    throw new Error("coordinates must be an Array");
+  }
+  if (coordinates.length < 2) {
+    throw new Error("coordinates must be at least 2 numbers long");
+  }
+  if (!isNumber(coordinates[0]) || !isNumber(coordinates[1])) {
+    throw new Error("coordinates must contain numbers");
+  }
+  const geom = {
+    type: "Point",
+    coordinates
+  };
+  return feature(geom, properties, options);
+}
+function polygon(coordinates, properties, options = {}) {
+  for (const ring of coordinates) {
+    if (ring.length < 4) {
+      throw new Error(
+        "Each LinearRing of a Polygon must have 4 or more Positions."
+      );
+    }
+    if (ring[ring.length - 1].length !== ring[0].length) {
+      throw new Error("First and last Position are not equivalent.");
+    }
+    for (let j = 0; j < ring[ring.length - 1].length; j++) {
+      if (ring[ring.length - 1][j] !== ring[0][j]) {
+        throw new Error("First and last Position are not equivalent.");
       }
     }
+  }
+  const geom = {
+    type: "Polygon",
+    coordinates
+  };
+  return feature(geom, properties, options);
+}
+function lineString(coordinates, properties, options = {}) {
+  if (coordinates.length < 2) {
+    throw new Error("coordinates must be an array of two or more positions");
+  }
+  const geom = {
+    type: "LineString",
+    coordinates
+  };
+  return feature(geom, properties, options);
+}
+function featureCollection(features, options = {}) {
+  const fc = { type: "FeatureCollection" };
+  if (options.id) {
+    fc.id = options.id;
+  }
+  if (options.bbox) {
+    fc.bbox = options.bbox;
+  }
+  fc.features = features;
+  return fc;
+}
+function multiLineString(coordinates, properties, options = {}) {
+  const geom = {
+    type: "MultiLineString",
+    coordinates
+  };
+  return feature(geom, properties, options);
+}
+function isNumber(num) {
+  return !isNaN(num) && num !== null && !Array.isArray(num);
+}
+function isObject(input) {
+  return input !== null && typeof input === "object" && !Array.isArray(input);
+}
+
+// src/data/utils/findContaining.ts
+var import_center = require("@turf/center");
+var import_area = require("@turf/area");
+var findContainingUnit = (poi, units) => {
+  const sameLevelUnits = units.filter(
+    (unit) => unit.properties.level_id === poi.properties.level_id
   );
-  return unit;
+  if (sameLevelUnits.length === 0) return null;
+  const hitAtCenter = sameLevelUnits.find((unit) => (0, import_boolean_point_in_polygon.booleanPointInPolygon)((0, import_center.center)(poi), unit));
+  if (hitAtCenter) return hitAtCenter;
+  let overlapCandidate = null;
+  let bestOverlapScore = 0;
+  for (const unit of sameLevelUnits) {
+    try {
+      const overlap = (0, import_intersect.intersect)(featureCollection([poi, unit]));
+      if (!overlap) continue;
+      const overlapArea = (0, import_area.area)(overlap);
+      if (overlapArea > bestOverlapScore) {
+        bestOverlapScore = overlapArea;
+        overlapCandidate = unit;
+      }
+    } catch (e) {
+      console.log(`Cannot compare POI (${poi.id}) with unit (${unit.id}):`, e.message);
+    }
+  }
+  if (overlapCandidate && bestOverlapScore > 0) return overlapCandidate;
+  return null;
 };
 var findContainingUnitAtPoint = (point3, levelId, units) => {
   const unit = units.find(
@@ -267,7 +395,17 @@ var findContainingUnitAtPoint = (point3, levelId, units) => {
       }
     }
   );
-  return unit;
+  return unit ? unit : null;
+};
+
+// src/data/utils/getPointOnFeature.ts
+var import_center2 = require("@turf/center");
+var import_boolean_point_in_polygon2 = __toESM(require("@turf/boolean-point-in-polygon"));
+var import_point_on_feature = __toESM(require("@turf/point-on-feature"));
+var getPointOnFeature = (feature3) => {
+  const c = (0, import_center2.center)(feature3);
+  if ((0, import_boolean_point_in_polygon2.default)(c, feature3)) return c;
+  return (0, import_point_on_feature.default)(feature3);
 };
 
 // src/data/utils/trace.ts
@@ -435,8 +573,8 @@ var safeFetchFeature = async (featureType, params) => {
 var import_query_core = require("@tanstack/query-core");
 
 // src/data/populator/index.ts
-var import_center = require("@turf/center");
-var import_boolean_point_in_polygon2 = require("@turf/boolean-point-in-polygon");
+var import_center3 = require("@turf/center");
+var import_boolean_point_in_polygon3 = require("@turf/boolean-point-in-polygon");
 var import_lodash3 = __toESM(require("lodash"));
 var createPopulator = ({
   internalFindById,
@@ -448,7 +586,29 @@ var createPopulator = ({
   const populateFootprint = (footprint) => Promise.resolve(footprint);
   const populateGeofence = (geofence) => Promise.resolve(geofence);
   const populatePrivilege = (privilege) => Promise.resolve(privilege);
-  const populateEvent = (event) => Promise.resolve(event);
+  const populateEvent = async (event) => {
+    const { feature_id, venue_id, local_category_ids = [] } = event.properties;
+    const venue = await internalFindById(venue_id);
+    const feature3 = await internalFindById(feature_id);
+    const localCategories = (await Promise.all(
+      local_category_ids.map((id) => internalFindById(id))
+    )).filter(Boolean);
+    const [parentCategories, subCategories] = import_lodash3.default.partition(
+      localCategories,
+      (cat) => cat?.properties.parent_id === null
+    );
+    return {
+      ...event,
+      properties: {
+        ...event.properties,
+        venue,
+        feature: feature3,
+        local_categories: localCategories,
+        local_parent_categories: parentCategories,
+        local_sub_categories: subCategories
+      }
+    };
+  };
   const populatePromotion = async (promotion) => {
     const { feature_id, venue_id, local_category_ids = [] } = promotion.properties;
     const venue = await internalFindById(venue_id);
@@ -472,6 +632,16 @@ var createPopulator = ({
       }
     };
   };
+  const populateSponsoredContent = async (sc) => {
+    const { venue_id, feature_id } = sc;
+    const venue = await internalFindById(venue_id);
+    const feature3 = feature_id ? await internalFindById(feature_id) : null;
+    return {
+      ...sc,
+      venue,
+      feature: feature3
+    };
+  };
   const populateAmenity = async (amenity) => {
     const units = await Promise.all(
       amenity.properties.unit_ids.map(internalFindById)
@@ -483,7 +653,7 @@ var createPopulator = ({
     const ordinalKiosks = kiosks.filter(
       (kiosk2) => kiosk2.properties.level_id === defaultLevel.id
     );
-    const kiosk = ordinalKiosks.find((kiosk2) => (0, import_boolean_point_in_polygon2.booleanPointInPolygon)(amenity, kiosk2));
+    const kiosk = ordinalKiosks.find((kiosk2) => (0, import_boolean_point_in_polygon3.booleanPointInPolygon)(amenity, kiosk2));
     return {
       ...amenity,
       properties: {
@@ -502,7 +672,7 @@ var createPopulator = ({
     const venue = await internalFindById(unit.properties.venue_id);
     const level = await internalFindById(unit.properties.level_id);
     const sections = await internalFilterByType("section");
-    const section = sections.find((section2) => (0, import_boolean_point_in_polygon2.booleanPointInPolygon)(anchor, section2));
+    const section = sections.find((section2) => (0, import_boolean_point_in_polygon3.booleanPointInPolygon)(anchor, section2));
     return {
       ...anchor,
       properties: {
@@ -539,7 +709,7 @@ var createPopulator = ({
     let section = null;
     if (anchor) {
       const sections = await internalFilterByType("section");
-      section = sections.find((section2) => (0, import_boolean_point_in_polygon2.booleanPointInPolygon)(anchor, section2));
+      section = sections.find((section2) => (0, import_boolean_point_in_polygon3.booleanPointInPolygon)(anchor, section2));
     }
     return {
       ...kiosk,
@@ -656,7 +826,7 @@ var createPopulator = ({
     const level = await internalFindById(unit.properties.level_id);
     const sections = await internalFilterByType("section");
     try {
-      const section = unit.geometry.type !== "MultiPolygon" ? sections.find((section2) => (0, import_boolean_point_in_polygon2.booleanPointInPolygon)((0, import_center.center)(unit), section2)) : null;
+      const section = unit.geometry.type !== "MultiPolygon" ? sections.find((section2) => (0, import_boolean_point_in_polygon3.booleanPointInPolygon)((0, import_center3.center)(unit), section2)) : null;
       return {
         ...unit,
         properties: {
@@ -723,7 +893,8 @@ var createPopulator = ({
     unit: populateUnit,
     venue: populateVenue,
     taxonomy: populateTaxonomy,
-    model3d: populateModel3D
+    model3d: populateModel3D,
+    "sponsored-content": populateSponsoredContent
   };
 };
 
@@ -732,25 +903,25 @@ var import_distance = require("@turf/distance");
 var import_rhumb_bearing = require("@turf/rhumb-bearing");
 
 // ../../node_modules/@turf/rhumb-destination/node_modules/@turf/helpers/dist/esm/index.js
-var earthRadius = 63710088e-1;
-var factors = {
-  centimeters: earthRadius * 100,
-  centimetres: earthRadius * 100,
+var earthRadius2 = 63710088e-1;
+var factors2 = {
+  centimeters: earthRadius2 * 100,
+  centimetres: earthRadius2 * 100,
   degrees: 360 / (2 * Math.PI),
-  feet: earthRadius * 3.28084,
-  inches: earthRadius * 39.37,
-  kilometers: earthRadius / 1e3,
-  kilometres: earthRadius / 1e3,
-  meters: earthRadius,
-  metres: earthRadius,
-  miles: earthRadius / 1609.344,
-  millimeters: earthRadius * 1e3,
-  millimetres: earthRadius * 1e3,
-  nauticalmiles: earthRadius / 1852,
+  feet: earthRadius2 * 3.28084,
+  inches: earthRadius2 * 39.37,
+  kilometers: earthRadius2 / 1e3,
+  kilometres: earthRadius2 / 1e3,
+  meters: earthRadius2,
+  metres: earthRadius2,
+  miles: earthRadius2 / 1609.344,
+  millimeters: earthRadius2 * 1e3,
+  millimetres: earthRadius2 * 1e3,
+  nauticalmiles: earthRadius2 / 1852,
   radians: 1,
-  yards: earthRadius * 1.0936
+  yards: earthRadius2 * 1.0936
 };
-function feature(geom, properties, options = {}) {
+function feature2(geom, properties, options = {}) {
   const feat = { type: "Feature" };
   if (options.id === 0 || options.id) {
     feat.id = options.id;
@@ -762,7 +933,7 @@ function feature(geom, properties, options = {}) {
   feat.geometry = geom;
   return feat;
 }
-function point(coordinates, properties, options = {}) {
+function point2(coordinates, properties, options = {}) {
   if (!coordinates) {
     throw new Error("coordinates is required");
   }
@@ -772,28 +943,28 @@ function point(coordinates, properties, options = {}) {
   if (coordinates.length < 2) {
     throw new Error("coordinates must be at least 2 numbers long");
   }
-  if (!isNumber(coordinates[0]) || !isNumber(coordinates[1])) {
+  if (!isNumber2(coordinates[0]) || !isNumber2(coordinates[1])) {
     throw new Error("coordinates must contain numbers");
   }
   const geom = {
     type: "Point",
     coordinates
   };
-  return feature(geom, properties, options);
+  return feature2(geom, properties, options);
 }
 function radiansToLength(radians, units = "kilometers") {
-  const factor = factors[units];
+  const factor = factors2[units];
   if (!factor) {
     throw new Error(units + " units is invalid");
   }
   return radians * factor;
 }
-function lengthToRadians(distance6, units = "kilometers") {
-  const factor = factors[units];
+function lengthToRadians(distance7, units = "kilometers") {
+  const factor = factors2[units];
   if (!factor) {
     throw new Error(units + " units is invalid");
   }
-  return distance6 / factor;
+  return distance7 / factor;
 }
 function degreesToRadians(degrees) {
   const normalisedDegrees = degrees % 360;
@@ -805,16 +976,16 @@ function convertLength(length, originalUnit = "kilometers", finalUnit = "kilomet
   }
   return radiansToLength(lengthToRadians(length, originalUnit), finalUnit);
 }
-function isNumber(num) {
+function isNumber2(num) {
   return !isNaN(num) && num !== null && !Array.isArray(num);
 }
 
 // ../../node_modules/@turf/rhumb-destination/dist/esm/index.js
 var import_invariant = require("@turf/invariant");
-function rhumbDestination(origin, distance6, bearing, options = {}) {
-  const wasNegativeDistance = distance6 < 0;
+function rhumbDestination(origin, distance7, bearing, options = {}) {
+  const wasNegativeDistance = distance7 < 0;
   let distanceInMeters = convertLength(
-    Math.abs(distance6),
+    Math.abs(distance7),
     options.units,
     "meters"
   );
@@ -826,11 +997,11 @@ function rhumbDestination(origin, distance6, bearing, options = {}) {
     bearing
   );
   destination[0] += destination[0] - coords[0] > 180 ? -360 : coords[0] - destination[0] > 180 ? 360 : 0;
-  return point(destination, options.properties);
+  return point2(destination, options.properties);
 }
-function calculateRhumbDestination(origin, distance6, bearing, radius) {
-  radius = radius === void 0 ? earthRadius : Number(radius);
-  const delta = distance6 / radius;
+function calculateRhumbDestination(origin, distance7, bearing, radius) {
+  radius = radius === void 0 ? earthRadius2 : Number(radius);
+  const delta = distance7 / radius;
   const lambda1 = origin[0] * Math.PI / 180;
   const phi1 = degreesToRadians(origin[1]);
   const theta = degreesToRadians(bearing);
@@ -851,113 +1022,6 @@ function calculateRhumbDestination(origin, distance6, bearing, radius) {
   ];
 }
 
-// node_modules/@turf/helpers/dist/esm/index.js
-var earthRadius2 = 63710088e-1;
-var factors2 = {
-  centimeters: earthRadius2 * 100,
-  centimetres: earthRadius2 * 100,
-  degrees: 360 / (2 * Math.PI),
-  feet: earthRadius2 * 3.28084,
-  inches: earthRadius2 * 39.37,
-  kilometers: earthRadius2 / 1e3,
-  kilometres: earthRadius2 / 1e3,
-  meters: earthRadius2,
-  metres: earthRadius2,
-  miles: earthRadius2 / 1609.344,
-  millimeters: earthRadius2 * 1e3,
-  millimetres: earthRadius2 * 1e3,
-  nauticalmiles: earthRadius2 / 1852,
-  radians: 1,
-  yards: earthRadius2 * 1.0936
-};
-function feature2(geom, properties, options = {}) {
-  const feat = { type: "Feature" };
-  if (options.id === 0 || options.id) {
-    feat.id = options.id;
-  }
-  if (options.bbox) {
-    feat.bbox = options.bbox;
-  }
-  feat.properties = properties || {};
-  feat.geometry = geom;
-  return feat;
-}
-function point2(coordinates, properties, options = {}) {
-  if (!coordinates) {
-    throw new Error("coordinates is required");
-  }
-  if (!Array.isArray(coordinates)) {
-    throw new Error("coordinates must be an Array");
-  }
-  if (coordinates.length < 2) {
-    throw new Error("coordinates must be at least 2 numbers long");
-  }
-  if (!isNumber2(coordinates[0]) || !isNumber2(coordinates[1])) {
-    throw new Error("coordinates must contain numbers");
-  }
-  const geom = {
-    type: "Point",
-    coordinates
-  };
-  return feature2(geom, properties, options);
-}
-function polygon(coordinates, properties, options = {}) {
-  for (const ring of coordinates) {
-    if (ring.length < 4) {
-      throw new Error(
-        "Each LinearRing of a Polygon must have 4 or more Positions."
-      );
-    }
-    if (ring[ring.length - 1].length !== ring[0].length) {
-      throw new Error("First and last Position are not equivalent.");
-    }
-    for (let j = 0; j < ring[ring.length - 1].length; j++) {
-      if (ring[ring.length - 1][j] !== ring[0][j]) {
-        throw new Error("First and last Position are not equivalent.");
-      }
-    }
-  }
-  const geom = {
-    type: "Polygon",
-    coordinates
-  };
-  return feature2(geom, properties, options);
-}
-function lineString(coordinates, properties, options = {}) {
-  if (coordinates.length < 2) {
-    throw new Error("coordinates must be an array of two or more positions");
-  }
-  const geom = {
-    type: "LineString",
-    coordinates
-  };
-  return feature2(geom, properties, options);
-}
-function featureCollection(features, options = {}) {
-  const fc = { type: "FeatureCollection" };
-  if (options.id) {
-    fc.id = options.id;
-  }
-  if (options.bbox) {
-    fc.bbox = options.bbox;
-  }
-  fc.features = features;
-  return fc;
-}
-function multiLineString(coordinates, properties, options = {}) {
-  const geom = {
-    type: "MultiLineString",
-    coordinates
-  };
-  return feature2(geom, properties, options);
-}
-function isNumber2(num) {
-  return !isNaN(num) && num !== null && !Array.isArray(num);
-}
-function isObject(input) {
-  return input !== null && typeof input === "object" && !Array.isArray(input);
-}
-
 // src/data/navigate/services/landmark/utils/outerRingsToLine.ts
 var outerRingsToLine = (geom) => {
   if (geom.type === "Polygon") {
@@ -984,7 +1048,7 @@ var distanceToWall = (p, wallLines) => {
 };
 
 // src/data/navigate/services/landmark/utils/toLandmark.ts
-var import_center2 = require("@turf/center");
+var import_center4 = require("@turf/center");
 var occupantToLandmark = (occupant, findByIdSync) => {
   const locationType = occupant.properties.unit_id ? "unit" : "kiosk";
   const locationId = locationType === "unit" ? occupant.properties.unit_id : occupant.properties.kiosk_id;
@@ -994,7 +1058,7 @@ var occupantToLandmark = (occupant, findByIdSync) => {
   if (!level) return null;
   return {
     name: occupant.properties.name,
-    point: (0, import_center2.center)(location.geometry).geometry.coordinates,
+    point: (0, import_center4.center)(location.geometry).geometry.coordinates,
     boundary: outerRingsToLine(location.geometry),
     level_id: location.properties.level_id,
     is_priority: occupant.properties.is_landmark,
@@ -1006,7 +1070,7 @@ var unitToLandmark = (unit, findByIdSync) => {
   if (!level) return null;
   return {
     name: { en: unit.properties.category },
-    point: (0, import_center2.center)(unit.geometry).geometry.coordinates,
+    point: (0, import_center4.center)(unit.geometry).geometry.coordinates,
     boundary: outerRingsToLine(unit.geometry),
     level_id: unit.properties.level_id,
     is_priority: false,
@@ -1018,7 +1082,7 @@ var openingToLandmark = (opening, findByIdSync) => {
   if (!level) return null;
   return {
     name: opening.properties.name?.en ? opening.properties.name : { en: "Entrance / Exit" },
-    point: (0, import_center2.center)(opening.geometry).geometry.coordinates,
+    point: (0, import_center4.center)(opening.geometry).geometry.coordinates,
     level_id: opening.properties.level_id,
     is_priority: true,
     ordinal: level.properties.ordinal
@@ -1029,7 +1093,7 @@ var amenityToLandmark = (amenity, findByIdSync) => {
   if (!level) return null;
   return {
     name: amenity.properties.name ?? { en: amenity.properties.category, th: amenity.properties.category },
-    point: (0, import_center2.center)(amenity.geometry).geometry.coordinates,
+    point: (0, import_center4.center)(amenity.geometry).geometry.coordinates,
     level_id: amenity.properties.level_id,
     is_priority: true,
     ordinal: level.properties.ordinal
@@ -1082,7 +1146,7 @@ var createLandmarkService = (ctx) => {
 
 // src/data/navigate/context/createNavigateContext.ts
 var createFindByIdSync = (data) => {
-  const { amenities = [], anchors = [], fixtures = [], levels = [], kiosks = [], relationships = [], occupants = [], openings = [], units } = data;
+  const { amenities = [], anchors = [], fixtures = [], levels = [], kiosks = [], relationships = [], occupants = [], openings = [], sections = [], units } = data;
   const featureById = /* @__PURE__ */ new Map();
   const entries = [
     ...amenities,
@@ -1093,6 +1157,7 @@ var createFindByIdSync = (data) => {
     ...relationships,
     ...occupants,
     ...openings,
+    ...sections,
     ...units
   ];
   for (const f of entries) featureById.set(f.id, f);
@@ -1113,17 +1178,17 @@ var createNavigateContext = (options) => {
 };
 
 // src/data/navigate/client.ts
-var import_boolean_point_in_polygon4 = require("@turf/boolean-point-in-polygon");
+var import_boolean_point_in_polygon5 = require("@turf/boolean-point-in-polygon");
 
 // src/data/navigate/services/graph/prepare.ts
-var import_lodash16 = __toESM(require("lodash"));
+var import_lodash19 = __toESM(require("lodash"));
 var import_node_dijkstra = __toESM(require("node-dijkstra"));
-var import_distance4 = require("@turf/distance");
-var import_center5 = require("@turf/center");
+var import_distance5 = require("@turf/distance");
+var import_center8 = require("@turf/center");
 
 // src/data/navigate/services/graph/nodemap/createTraversalNodeMap.ts
 var import_distance2 = require("@turf/distance");
-var import_center3 = require("@turf/center");
+var import_center5 = require("@turf/center");
 var import_lodash4 = __toESM(require("lodash"));
 
 // src/data/navigate/services/graph/constants.ts
@@ -1172,14 +1237,14 @@ var createTraversalNodeMap = (unitOpenings, options) => {
         const opening = features[currentIndex];
         const feature3 = features[j];
         try {
-          const distance6 = (0, import_distance2.distance)(
-            (0, import_center3.center)(opening.geometry),
-            (0, import_center3.center)(feature3.geometry),
+          const distance7 = (0, import_distance2.distance)(
+            (0, import_center5.center)(opening.geometry),
+            (0, import_center5.center)(feature3.geometry),
             { units: "meters" }
           ) + (distanceOptions?.baseDistance ?? 0);
           if (opening.id === feature3.id) continue;
-          import_lodash4.default.set(relationshipGraph, `${opening.id}.${feature3.id}`, distance6);
-          import_lodash4.default.set(relationshipGraph, `${feature3.id}.${opening.id}`, distance6);
+          import_lodash4.default.set(relationshipGraph, `${opening.id}.${feature3.id}`, distance7);
+          import_lodash4.default.set(relationshipGraph, `${feature3.id}.${opening.id}`, distance7);
           counter++;
         } catch (error) {
           continue;
@@ -1260,15 +1325,15 @@ var createElevatorNodeMap = (elevatorLikeRelationships, unitOpenings, options) =
           const { opening: theOpening, level: theLevel } = theConnection;
           if (theConnection.opening.id === otherConnection.opening.id) continue;
           const { opening: otherOpening, level: otherLevel } = otherConnection;
-          let distance6 = baseDistance;
+          let distance7 = baseDistance;
           if (scaleDistanceByLevel && theLevel && otherLevel) {
             const originOrdinal = theLevel.properties.ordinal;
             const connectionOrdinal = otherLevel.properties.ordinal;
             const levelDifference = Math.abs(originOrdinal - connectionOrdinal);
-            if (levelDifference > 0) distance6 *= levelDifference;
+            if (levelDifference > 0) distance7 *= levelDifference;
           }
-          import_lodash5.default.set(elevatorNodeMap, `${theOpening.id}.${otherOpening.id}`, distance6);
-          import_lodash5.default.set(elevatorNodeMap, `${otherOpening.id}.${theOpening.id}`, distance6);
+          import_lodash5.default.set(elevatorNodeMap, `${theOpening.id}.${otherOpening.id}`, distance7);
+          import_lodash5.default.set(elevatorNodeMap, `${otherOpening.id}.${theOpening.id}`, distance7);
           counter++;
         }
       }
@@ -1328,28 +1393,35 @@ var createRampNodeMap = (relationships, options) => {
 
 // src/data/navigate/services/graph/nodemap/createStairNodeMap.ts
 var import_lodash9 = __toESM(require("lodash"));
-var createStairNodeMap = (elevatorLikeRelationships, unitOpenings, options) => {
+var createStairNodeMap = (stairLikeRelationships, unitOpenings, options) => {
   const t0 = performance.now();
   const { levels = [], openings = [], units = [] } = options.data;
   const { baseDistance, scaleDistanceByLevel } = getDistanceOptions(options.unitDistanceOptions, "stairs");
   let elevatorNodeMap = {};
   let counter = 0;
-  for (const relationship of elevatorLikeRelationships) {
+  for (const relationship of stairLikeRelationships) {
     try {
       const {
-        origin: { id: originId },
+        origin: originTypeAndId,
+        // opening
         intermediary,
-        destination: { id: destinationId }
+        // units
+        destination: destinationTypeAndId
+        // opening
       } = relationship.properties;
-      const origin = openings.find((opening) => opening.id === originId);
-      if (!origin) return;
-      const originLevel = levels.find((level) => level.id === origin.properties.level_id);
-      const destination = openings.find((opening) => opening.id === destinationId);
-      const destinationOpeningAndLevel = {
-        opening: destination,
-        level: levels.find((level) => level.id === destination.properties.level_id)
-      };
-      const intermediaryOpeningAndLevels = intermediary.map((unitTypeAndId) => {
+      const origin = openings.find((opening) => opening.id === originTypeAndId.id);
+      let originOpeningAndLevels = [];
+      if (origin) {
+        const originLevel = levels.find((level) => level.id === origin?.properties.level_id);
+        originOpeningAndLevels.push({ opening: origin, level: originLevel });
+      }
+      const destination = openings.find((opening) => opening.id === destinationTypeAndId.id);
+      let destinationOpeningAndLevels = [];
+      if (destination) {
+        const destinationLevel = levels.find((level) => level.id === destination?.properties.level_id);
+        destinationOpeningAndLevels.push({ opening: destination, level: destinationLevel });
+      }
+      const intermediaryOpeningAndLevels = (intermediary || []).map((unitTypeAndId) => {
         const openings2 = unitOpenings[unitTypeAndId.id];
         const unit = units.find((unit2) => unit2.id === unitTypeAndId.id);
         if (!unit) return [];
@@ -1357,20 +1429,28 @@ var createStairNodeMap = (elevatorLikeRelationships, unitOpenings, options) => {
         if (!level) return [];
         return openings2.map((opening) => ({ opening, level }));
       }).flat();
-      const connections = [...intermediaryOpeningAndLevels, destinationOpeningAndLevel];
-      if (!origin) return;
-      for (const connection of connections) {
-        const { opening, level } = connection;
-        let distance6 = baseDistance;
-        if (scaleDistanceByLevel) {
-          const originOrdinal = originLevel.properties.ordinal;
-          const connectionOrdinal = level.properties.ordinal;
-          const levelDifference = Math.abs(originOrdinal - connectionOrdinal);
-          if (levelDifference > 0) distance6 *= levelDifference;
+      const connections = compact([
+        ...originOpeningAndLevels,
+        ...intermediaryOpeningAndLevels,
+        ...destinationOpeningAndLevels
+      ]);
+      if (connections.length === 0) return elevatorNodeMap;
+      for (const theConnection of connections) {
+        for (const otherConnection of connections) {
+          const { opening: theOpening, level: theLevel } = theConnection;
+          if (theConnection.opening.id === otherConnection.opening.id) continue;
+          const { opening: otherOpening, level: otherLevel } = otherConnection;
+          let distance7 = baseDistance;
+          if (scaleDistanceByLevel && theLevel && otherLevel) {
+            const originOrdinal = theLevel.properties.ordinal;
+            const connectionOrdinal = otherLevel.properties.ordinal;
+            const levelDifference = Math.abs(originOrdinal - connectionOrdinal);
+            if (levelDifference > 0) distance7 *= levelDifference;
+          }
+          import_lodash9.default.set(elevatorNodeMap, `${theOpening.id}.${otherOpening.id}`, distance7);
+          import_lodash9.default.set(elevatorNodeMap, `${otherOpening.id}.${theOpening.id}`, distance7);
+          counter++;
         }
-        import_lodash9.default.set(elevatorNodeMap, `${origin.id}.${opening.id}`, distance6);
-        import_lodash9.default.set(elevatorNodeMap, `${opening.id}.${origin.id}`, distance6);
-        counter++;
       }
     } catch (err) {
       console.warn(
@@ -1390,7 +1470,7 @@ var createStairNodeMap = (elevatorLikeRelationships, unitOpenings, options) => {
 };
 
 // src/data/navigate/services/graph/nodemap/createOccupantNodeMap.ts
-var import_lodash10 = __toESM(require("lodash"));
+var import_lodash11 = __toESM(require("lodash"));
 var createOccupantNodeMap = (occupants) => {
   const t0 = performance.now();
   let nodeMap = {};
@@ -1400,13 +1480,13 @@ var createOccupantNodeMap = (occupants) => {
     const occupantRoomIds = compact(!is_maintenance ? [unit_id, ...unit_ids] : [temp_unit_id]);
     const occupantKioskIds = compact(!is_maintenance ? [kiosk_id, ...kiosk_ids] : [temp_kiosk_id]);
     for (const roomId of occupantRoomIds) {
-      import_lodash10.default.set(nodeMap, `${roomId}.${occupant.id}`, 1e-3);
-      import_lodash10.default.set(nodeMap, `${occupant.id}.${roomId}`, 1e-3);
+      import_lodash11.default.set(nodeMap, `${roomId}.${occupant.id}`, 1e-3);
+      import_lodash11.default.set(nodeMap, `${occupant.id}.${roomId}`, 1e-3);
       counter++;
     }
     for (const kioskId of occupantKioskIds) {
-      import_lodash10.default.set(nodeMap, `${kioskId}.${occupant.id}`, 1e-3);
-      import_lodash10.default.set(nodeMap, `${occupant.id}.${kioskId}`, 1e-3);
+      import_lodash11.default.set(nodeMap, `${kioskId}.${occupant.id}`, 1e-3);
+      import_lodash11.default.set(nodeMap, `${occupant.id}.${kioskId}`, 1e-3);
       counter++;
     }
   });
@@ -1415,11 +1495,11 @@ var createOccupantNodeMap = (occupants) => {
   return nodeMap;
 };
 
-// src/data/navigate/services/graph/nodemap/createPOINodeMaps.ts
-var import_center4 = require("@turf/center");
+// src/data/navigate/services/graph/nodemap/createPoiToWalkwayOpeningNodeMap.ts
+var import_center6 = require("@turf/center");
 var import_distance3 = require("@turf/distance");
-var import_lodash12 = __toESM(require("lodash"));
-var createPOINodeMap = (features, getFeatureUnit, unitOpenings) => {
+var import_lodash13 = __toESM(require("lodash"));
+var createPoiToWalkwayOpeningNodeMap = (features, getFeatureUnit, unitOpenings) => {
   const t0 = performance.now();
   let nodeMap = {};
   let counter = 0;
@@ -1428,13 +1508,13 @@ var createPOINodeMap = (features, getFeatureUnit, unitOpenings) => {
       const locatedOnUnitId = getFeatureUnit(feat);
       if (locatedOnUnitId) {
         const openings = unitOpenings[locatedOnUnitId] ?? [];
-        const center4 = (0, import_center4.center)(feat);
+        const center6 = (0, import_center6.center)(feat);
         for (const opening of openings) {
           try {
-            const openingCenter = (0, import_center4.center)(opening);
-            const dis = (0, import_distance3.distance)(center4, openingCenter, { units: "meters" }) + BASE_POI_BASEDISTANCE;
-            import_lodash12.default.set(nodeMap, `${opening.id}.${feat.id}`, dis);
-            import_lodash12.default.set(nodeMap, `${feat.id}.${opening.id}`, dis);
+            const openingCenter = (0, import_center6.center)(opening);
+            const dis = (0, import_distance3.distance)(center6, openingCenter, { units: "meters" }) + BASE_POI_BASEDISTANCE;
+            import_lodash13.default.set(nodeMap, `${opening.id}.${feat.id}`, dis);
+            import_lodash13.default.set(nodeMap, `${feat.id}.${opening.id}`, dis);
             counter++;
           } catch (err) {
             console.log(err, opening);
@@ -1452,6 +1532,35 @@ var createPOINodeMap = (features, getFeatureUnit, unitOpenings) => {
   return nodeMap;
 };
 
+// src/data/navigate/services/graph/nodemap/createWalkwayNodeMap.ts
+var import_lodash14 = __toESM(require("lodash"));
+var import_distance4 = require("@turf/distance");
+var import_center7 = require("@turf/center");
+var createWalkwayNodeMap = (poiOnWalkways) => {
+  const t0 = performance.now();
+  let nodeMap = {};
+  let counter = 0;
+  for (const [walkwayId, pois] of Object.entries(poiOnWalkways)) {
+    if (pois.length > 1) {
+      for (let i = 0; i < pois.length; i++) {
+        const thisPoi = pois[i];
+        for (let j = 0; j < pois.length; j++) {
+          const thatPoi = pois[j];
+          if (thisPoi.id !== thatPoi.id) {
+            const dis = (0, import_distance4.distance)((0, import_center7.center)(thisPoi), (0, import_center7.center)(thatPoi), { units: "meters" });
+            import_lodash14.default.set(nodeMap, `${thisPoi.id}.${thatPoi.id}`, dis);
+            import_lodash14.default.set(nodeMap, `${thatPoi.id}.${thisPoi.id}`, dis);
+            counter++;
+          }
+        }
+      }
+    }
+  }
+  const t1 = performance.now();
+  trace("nav", `  \u2502    \u251C\u2500 add ${counter} within same walkway relationships`, t1 - t0);
+  return nodeMap;
+};
+
 // src/data/navigate/services/graph/utils/mergeNodeMap.ts
 var mergeNodeMap = (nodeMaps) => {
   const out = {};
@@ -1467,7 +1576,7 @@ var mergeNodeMap = (nodeMaps) => {
 };
 
 // src/data/navigate/services/graph/utils/createUnitOpenings.ts
-var import_lodash13 = require("lodash");
+var import_lodash15 = require("lodash");
 var createUnitOpenings = (relationships, units, openings) => {
   const openingConnections = {};
   const relationshipMap = /* @__PURE__ */ new Map();
@@ -1493,7 +1602,7 @@ var createUnitOpenings = (relationships, units, openings) => {
     const relationshipIntermediary = relationshipIntermediaryTypeAndId.map(({ id }) => {
       return openings.find((opening) => !!opening && opening.id === id);
     });
-    openingConnections[unitId] = (0, import_lodash13.uniqBy)(
+    openingConnections[unitId] = (0, import_lodash15.uniqBy)(
       [...openingConnections[unitId] || [], ...relationshipIntermediary],
       "id"
     );
@@ -1507,18 +1616,49 @@ var parseOrdinalCoordinate = (id) => {
 };
 
 // src/data/navigate/services/graph/utils/createUnitsKiosks.ts
-var import_lodash15 = require("lodash");
+var import_lodash17 = require("lodash");
 var createUnitsKiosks = (units, kiosks) => {
   const unitsWithKiosks = {};
   kiosks.forEach((kiosk) => {
     const unitId = findContainingUnit(kiosk, units)?.id;
     if (!unitId) return;
-    const prevValues = (0, import_lodash15.get)(unitsWithKiosks, unitId, []);
-    (0, import_lodash15.set)(unitsWithKiosks, unitId, [...prevValues, kiosk]);
+    const prevValues = (0, import_lodash17.get)(unitsWithKiosks, unitId, []);
+    (0, import_lodash17.set)(unitsWithKiosks, unitId, [...prevValues, kiosk]);
   });
   return unitsWithKiosks;
 };
 
+// src/data/navigate/services/graph/utils/createUnitsAmenities.ts
+var import_lodash18 = require("lodash");
+var createUnitsAmenities = (units, amenities) => {
+  const unitsWithAmenities = {};
+  amenities.forEach((amenity) => {
+    const unitId = findContainingUnit(amenity, units)?.id;
+    if (!unitId) return;
+    const prevValues = (0, import_lodash18.get)(unitsWithAmenities, unitId, []);
+    (0, import_lodash18.set)(unitsWithAmenities, unitId, [...prevValues, amenity]);
+  });
+  return unitsWithAmenities;
+};
+
+// src/data/navigate/constants.ts
+var WALKABLE_UNIT_CATEGORY = [
+  "walkway",
+  "parking",
+  "room",
+  "terrace",
+  "unenclosedarea",
+  "vegetation",
+  "unspecified"
+];
+var VERTICAL_TRAVERSAL_CATEGORY = [
+  "elevator",
+  "escalator",
+  "stairs",
+  "stairs.emergencyexit",
+  "ramp"
+];
+
 // src/data/navigate/services/graph/prepare.ts
 var prepareGraph = (options) => {
   const {
@@ -1529,7 +1669,8 @@ var prepareGraph = (options) => {
       relationships = [],
       openings = [],
       units = [],
-      kiosks = []
+      kiosks = [],
+      sections = []
     }
   } = options;
   const {
@@ -1538,10 +1679,12 @@ var prepareGraph = (options) => {
     ramp: rampRelationships = [],
     elevator: elevatorRelationships = [],
     stairs: stairsRelationships = []
-  } = import_lodash16.default.groupBy(relationships, "properties.category");
+  } = import_lodash19.default.groupBy(relationships, "properties.category");
   const unitOpenings = createUnitOpenings(traversalRelationships, units, openings);
-  const walkwayUnits = units.filter((unit) => unit.properties.category === "walkway");
+  const walkableUnits = units.filter((unit) => WALKABLE_UNIT_CATEGORY.includes(unit.properties.category));
+  const walkwayUnits = walkableUnits.filter((unit) => unit.properties.category === "walkway");
   const unitKiosks = createUnitsKiosks(walkwayUnits, kiosks);
+  const unitAmenities = createUnitsAmenities(walkwayUnits, amenities);
   const traversalNodeMap = createTraversalNodeMap(unitOpenings, options);
   const escalatorNodeMap = createEscalatorNodeMap(escalatorRelationships, options);
   const rampNodeMap = createRampNodeMap(rampRelationships, options);
@@ -1555,10 +1698,26 @@ var prepareGraph = (options) => {
     unitOpenings,
     options
   );
-  const amenityNodeMap = createPOINodeMap(amenities, (amenity) => amenity.properties.unit_ids?.[0] || null, unitOpenings);
-  const anchorsNodeMap = createPOINodeMap(anchors, (anchor) => anchor.properties.unit_id, unitOpenings);
-  const kioskNodeMap = createPOINodeMap(kiosks, (kiosk) => findContainingUnit(kiosk, walkwayUnits)?.id, unitOpenings);
-  const unitNodeMap = createPOINodeMap(units, (unit) => unit.id, unitOpenings);
+  const amenityNodeMap = createPoiToWalkwayOpeningNodeMap(amenities, (amenity) => amenity?.properties?.unit_ids?.[0] || null, unitOpenings);
+  const anchorsNodeMap = createPoiToWalkwayOpeningNodeMap(anchors, (anchor) => anchor?.properties?.unit_id, unitOpenings);
+  const sectionNodeMap = createPoiToWalkwayOpeningNodeMap(
+    sections,
+    (section) => {
+      const sectionLevelId = section?.properties?.level_id;
+      const displayPoint = section?.properties?.display_point;
+      const unit = findContainingUnitAtPoint(displayPoint, sectionLevelId, walkableUnits) || findContainingUnit(section, walkableUnits);
+      if (!unit) {
+        console.warn(`[venue-js] Section ${section.id} on level ${section?.properties?.level_id} has no walkable containing unit \u2014 section will be excluded from routing.`);
+        return null;
+      }
+      return unit.id;
+    },
+    unitOpenings
+  );
+  const kioskNodeMap = createPoiToWalkwayOpeningNodeMap(kiosks, (kiosk) => findContainingUnit(kiosk, walkwayUnits)?.id || null, unitOpenings);
+  const poiOnWalkways = import_lodash19.default.mergeWith({}, unitKiosks, unitAmenities, (objValue = [], srcValue = []) => objValue.concat(srcValue));
+  const walkwayNodeMap = createWalkwayNodeMap(poiOnWalkways);
+  const unitNodeMap = createPoiToWalkwayOpeningNodeMap(units, (unit) => unit.id, unitOpenings);
   const occupantNodeMap = createOccupantNodeMap(occupants);
   const defaultGraph = new import_node_dijkstra.default(mergeNodeMap([
     traversalNodeMap,
@@ -1568,7 +1727,9 @@ var prepareGraph = (options) => {
     stairNodeMap,
     amenityNodeMap,
     anchorsNodeMap,
+    sectionNodeMap,
     kioskNodeMap,
+    walkwayNodeMap,
     unitNodeMap,
     occupantNodeMap
   ]));
@@ -1578,7 +1739,9 @@ var prepareGraph = (options) => {
     elevatorNodeMap,
     amenityNodeMap,
     anchorsNodeMap,
+    sectionNodeMap,
     kioskNodeMap,
+    walkwayNodeMap,
     unitNodeMap,
     occupantNodeMap
   ]));
@@ -1589,8 +1752,8 @@ var prepareGraph = (options) => {
       const kiosks2 = unitKiosks[locatedOnUnit.id] ?? [];
       const routingGraphs = [accessibleGraph, defaultGraph];
       for (const opening of openings2) {
-        const openingCenter = (0, import_center5.center)(opening);
-        const dis = (0, import_distance4.distance)([lng, lat], openingCenter, { units: "meters" });
+        const openingCenter = (0, import_center8.center)(opening);
+        const dis = (0, import_distance5.distance)([lng, lat], openingCenter, { units: "meters" });
         for (const routingGraph of routingGraphs) {
           const updatedCoordsNodeGraph = routingGraph?.graph?.get(params) ?? /* @__PURE__ */ new Map();
           updatedCoordsNodeGraph.set(opening.id, dis);
@@ -1600,8 +1763,8 @@ var prepareGraph = (options) => {
         }
       }
       for (const kiosk of kiosks2) {
-        const kioskCenter = (0, import_center5.center)(kiosk);
-        const dis = (0, import_distance4.distance)([lng, lat], kioskCenter, { units: "meters" });
+        const kioskCenter = (0, import_center8.center)(kiosk);
+        const dis = (0, import_distance5.distance)([lng, lat], kioskCenter, { units: "meters" });
         for (const routingGraph of routingGraphs) {
           const updatedCoordsNodeGraph = routingGraph?.graph?.get(params) ?? /* @__PURE__ */ new Map();
           updatedCoordsNodeGraph.set(kiosk.id, dis);
@@ -1619,16 +1782,16 @@ var prepareGraph = (options) => {
 var import_length = __toESM(require("@turf/length"));
 var WALKING_SPEED = 1.4;
 var calculatePathLength = (feature3) => (0, import_length.default)(feature3, { units: "kilometers" }) * 1e3;
-var calculateTravelingDuration = (distance6) => {
-  const duration = distance6 / WALKING_SPEED;
+var calculateTravelingDuration = (distance7) => {
+  const duration = distance7 / WALKING_SPEED;
   const minutes = Math.round(duration / 60);
   return minutes > 0 ? minutes : 1;
 };
 var calculateTotalDistance = (steps = []) => {
   return steps.reduce((acc, { path }) => acc + calculatePathLength(lineString(path)), 0);
 };
-var calculateRoundedDistance = (distance6) => {
-  return Math.round(distance6 - distance6 % 25);
+var calculateRoundedDistance = (distance7) => {
+  return Math.round(distance7 - distance7 % 25);
 };
 
 // src/data/navigate/type-guard.ts
@@ -1637,7 +1800,7 @@ function isCoordinateOrdinalString(id) {
 }
 
 // src/data/navigate/services/waypoint/createWaypointService.ts
-var import_center6 = require("@turf/center");
+var import_center9 = require("@turf/center");
 
 // src/data/navigate/services/waypoint/extractEndWaypoint.ts
 var import_point_on_feature2 = __toESM(require("@turf/point-on-feature"));
@@ -1648,6 +1811,7 @@ var isUnit = (id) => !!id && id.startsWith("unit-");
 var isKiosk = (id) => !!id && id.startsWith("kiosk-");
 var isOpening = (id) => !!id && id.startsWith("opening-");
 var isAmenity = (id) => !!id && id.startsWith("amenity-");
+var isSection = (id) => !!id && id.startsWith("section-");
 
 // src/data/navigate/services/waypoint/extractEndWaypoint.ts
 var extractEndPoint = (path, ctx) => {
@@ -1720,6 +1884,22 @@ var extractEndPoint = (path, ctx) => {
       path.slice(0, -1)
     ];
   }
+  if (isSection(a) && isOpening(b)) {
+    const section = findByIdSync(a);
+    const level = findByIdSync(section.properties.level_id);
+    return [
+      {
+        id: a,
+        type: "end",
+        name: section.properties.name,
+        point: (0, import_point_on_feature2.default)(section).geometry.coordinates,
+        levelId: section.properties.level_id,
+        ordinal: level.properties.ordinal,
+        source: { type: "section", id: a }
+      },
+      path.slice(0, -1)
+    ];
+  }
   if (isUnit(a) && isOpening(b)) {
     const unit = findByIdSync(a);
     const opening = findByIdSync(b);
@@ -1846,6 +2026,22 @@ var extractStartPoint = (path, ctx) => {
       path.slice(1)
     ];
   }
+  if (isSection(a) && isOpening(b)) {
+    const section = findByIdSync(a);
+    const level = findByIdSync(section.properties.level_id);
+    return [
+      {
+        id: a,
+        type: "start",
+        name: section.properties.name,
+        point: (0, import_point_on_feature3.default)(section).geometry.coordinates,
+        levelId: section.properties.level_id,
+        ordinal: level.properties.ordinal,
+        source: { type: "section", id: a }
+      },
+      path.slice(1)
+    ];
+  }
   if (isUnit(a) && isOpening(b)) {
     const unit = findByIdSync(a);
     const opening = findByIdSync(b);
@@ -1907,7 +2103,7 @@ var createWaypointService = (ctx) => {
     const waypoints = middlePoints.map((openingId) => {
       const opening = findByIdSync(openingId);
       const level = findByIdSync(opening.properties.level_id);
-      const coordinates = (0, import_center6.center)(opening).geometry.coordinates;
+      const coordinates = (0, import_center9.center)(opening).geometry.coordinates;
       return {
         id: `${opening.properties.level_id}:${openingId}`,
         type: "between",
@@ -1915,6 +2111,7 @@ var createWaypointService = (ctx) => {
         name: null,
         levelId: opening.properties.level_id,
         ordinal: level.properties.ordinal,
+        checkpoint: opening.properties.category === "pedestrian.principal",
         source: { type: "opening", id: opening.id }
       };
     });
@@ -1924,53 +2121,12 @@ var createWaypointService = (ctx) => {
 };
 
 // src/data/navigate/services/instructions/createInstructionService.ts
-var import_distance6 = require("@turf/distance");
+var import_distance7 = require("@turf/distance");
 var import_rhumb_bearing3 = require("@turf/rhumb-bearing");
 
-// src/data/navigate/constants.ts
-var OBSTACLE_FEATURE_TYPES = [
-  "kiosk"
-  /* , "fixture" */
-];
-var OBSTACLE_CATEGORIES = [
-  "fixture.water",
-  "fixture.stage",
-  "nonpublic",
-  "opentobelow",
-  "elevator",
-  "escalator",
-  "stairs",
-  "stairs.emergencyexit",
-  "room",
-  "unspecified",
-  "structure",
-  "brick",
-  "concrete",
-  "drywall",
-  "glass",
-  "wood",
-  "column"
-];
-var WALKABLE_CATEGORY = [
-  "walkway",
-  "parking",
-  "room",
-  "terrace",
-  "unenclosedarea",
-  "vegetation",
-  "unspecified"
-];
-var VERTICAL_TRAVERSAL_CATEGORY = [
-  "elevator",
-  "escalator",
-  "stairs",
-  "stairs.emergencyexit",
-  "ramp"
-];
-
 // src/data/navigate/services/instructions/utils/outwardOpeningBearing.ts
 var import_rhumb_bearing2 = require("@turf/rhumb-bearing");
-var import_distance5 = require("@turf/distance");
+var import_distance6 = require("@turf/distance");
 var outwardOpeningBearing = (openingLine, nextPoint) => {
   const [p1, p2] = openingLine.coordinates;
   const openingBearing = (0, import_rhumb_bearing2.rhumbBearing)(p1, p2);
@@ -1986,7 +2142,7 @@ var outwardOpeningBearing = (openingLine, nextPoint) => {
   let minDist = Infinity;
   for (const b of candidates) {
     const testPoint = rhumbDestination(openingMid, 0.5, b, { units: "meters" }).geometry.coordinates;
-    const d = (0, import_distance5.distance)(nextPoint, testPoint, { units: "meters" });
+    const d = (0, import_distance6.distance)(nextPoint, testPoint, { units: "meters" });
     if (d < minDist) {
       minDist = d;
       best = b;
@@ -2085,7 +2241,7 @@ var createInstructionService = (ctx) => {
         if (turn === "straight") {
           continue;
         }
-        const distanceFromPreviousPoint = (0, import_distance6.distance)(prevPoint, thisPoint, { units: "meters" });
+        const distanceFromPreviousPoint = (0, import_distance7.distance)(prevPoint, thisPoint, { units: "meters" });
         if (distanceFromPreviousPoint < 20 && prevInstruction && sameDirectionalTurn(prevInstruction.turn, turn)) {
           const prevTurnSide = turnSide(prevInstruction.turn);
           const extendedTurn = getTurn(prevInstruction.bearing.from, toBearing2, prevTurnSide);
@@ -2097,7 +2253,7 @@ var createInstructionService = (ctx) => {
           prevInstruction.bearing.delta = angleDiff(prevInstruction.bearing.from, toBearing2);
           prevInstruction.turn = extendedTurn;
         } else {
-          const distanceSinceLastTurn = (0, import_distance6.distance)(prevTurnPoint, thisPoint, { units: "meters" });
+          const distanceSinceLastTurn = (0, import_distance7.distance)(prevTurnPoint, thisPoint, { units: "meters" });
           const landmark = landmarkService.findNearestLandmark(thisPoint, ordinal);
           const afterTurnToward2 = landmarkService.findTowardLandmark(thisPoint, nextPoint, ordinal);
           const instruction = {
@@ -2133,7 +2289,7 @@ var createInstructionService = (ctx) => {
 };
 
 // src/data/navigate/services/steps/createStepService.ts
-var import_lodash19 = require("lodash");
+var import_lodash22 = require("lodash");
 
 // src/data/navigate/services/description/describe.ts
 var t = (template, locale, options) => {
@@ -2149,11 +2305,17 @@ var describeVerticalStep = (fromLevel, toLevel, intermediary) => {
   };
 };
 var describeHorizontalStep = (intermediary, toward, landmark) => {
-  const template = `Follow the path ${intermediary === "walkway" ? `along the walkway` : `through {{intermediary}}`} ${toward ? `toward {{toward}}` : ``} ${!toward && landmark ? `near {{landmark}}` : ``}`.trim();
+  const segments = [
+    // fallback: skip "through" segment if intermediary is null/empty
+    intermediary === "walkway" ? "along the walkway" : intermediary ? "through {{intermediary}}" : null,
+    toward ? "toward {{toward}}" : null,
+    !toward && landmark ? "near {{landmark}}" : null
+  ].filter(Boolean);
+  const template = `Follow the path ${segments.join(" ")}`;
   return {
     text: t(template, "en", { intermediary, toward, landmark }),
     template,
-    options: { toward, landmark }
+    options: { intermediary, toward, landmark }
   };
 };
 var describeLastStep = () => {
@@ -2163,11 +2325,11 @@ var describeLastStep = () => {
 };
 
 // src/data/navigate/services/walkablepath/createWalkablePathUtils.ts
-var import_lodash18 = __toESM(require("lodash"));
+var import_lodash21 = __toESM(require("lodash"));
 var import_invariant3 = require("@turf/invariant");
+var import_buffer = require("@turf/buffer");
 var import_difference = __toESM(require("@turf/difference"));
 var import_envelope = __toESM(require("@turf/envelope"));
-var import_boolean_overlap = __toESM(require("@turf/boolean-overlap"));
 var import_boolean_intersects = __toESM(require("@turf/boolean-intersects"));
 
 // ../../node_modules/@turf/meta/dist/esm/index.js
@@ -2293,15 +2455,15 @@ function bbox(geojson, options = {}) {
 var index_default = bbox;
 
 // src/data/navigate/services/walkablepath/turf-shortest-path/v6.5.0/shortestPath.ts
-var import_boolean_point_in_polygon3 = __toESM(require("@turf/boolean-point-in-polygon"));
-var import_distance7 = __toESM(require("@turf/distance"));
+var import_boolean_point_in_polygon4 = __toESM(require("@turf/boolean-point-in-polygon"));
+var import_distance8 = __toESM(require("@turf/distance"));
 var import_transform_scale = __toESM(require("@turf/transform-scale"));
 var import_union = __toESM(require("@turf/union"));
 var import_bbox_polygon = __toESM(require("@turf/bbox-polygon"));
 var import_clean_coords = require("@turf/clean-coords");
 var import_invariant2 = require("@turf/invariant");
 var import_pathfinding = __toESM(require("pathfinding"));
-var import_lodash17 = require("lodash");
+var import_lodash20 = require("lodash");
 
 // src/data/navigate/services/walkablepath/turf-shortest-path/utils/stringPull.ts
 function stringPull(grid, path) {
@@ -2356,39 +2518,6 @@ function stringPull(grid, path) {
   return out;
 }
 
-// src/data/navigate/services/walkablepath/turf-shortest-path/utils/pruneSmallAngle.ts
-function pruneSmallAngles(path, minDeg = 10) {
-  if (path.length <= 2) return path;
-  const out = [path[0]];
-  for (let i = 1; i < path.length - 1; i++) {
-    const a = out.at(-1);
-    const b = path[i];
-    const c = path[i + 1];
-    const abx = b[0] - a[0], aby = b[1] - a[1];
-    const bcx = c[0] - b[0], bcy = c[1] - b[1];
-    const dot = abx * bcx + aby * bcy;
-    const ab = Math.hypot(abx, aby);
-    const bc = Math.hypot(bcx, bcy);
-    const angle = Math.acos(dot / (ab * bc)) * 180 / Math.PI;
-    if (angle > minDeg) out.push(b);
-  }
-  out.push(path.at(-1));
-  return out;
-}
-
-// src/data/navigate/services/walkablepath/turf-shortest-path/utils/pruneShortSegments.ts
-function pruneShortSegments(path, minLen = 2) {
-  const out = [path[0]];
-  for (let i = 1; i < path.length; i++) {
-    const [x0, y0] = out.at(-1);
-    const [x1, y1] = path[i];
-    if (Math.hypot(x1 - x0, y1 - y0) >= minLen) {
-      out.push(path[i]);
-    }
-  }
-  return out;
-}
-
 // src/data/navigate/services/walkablepath/turf-shortest-path/utils/clearance.ts
 function buildClearanceGrid(matrix) {
   const h = matrix.length;
@@ -2440,7 +2569,7 @@ function snapPointToClearancePeak(p, clearance, isWalkableCell, radius = 4) {
       const y = py + dy;
       if (!isWalkableCell(x, y)) continue;
       const score = clearance[y][x];
-      const penalty = Math.hypot(dx, dy) * 5e-3;
+      const penalty = Math.hypot(dx, dy) * 0.5;
       const finalScore = score - penalty;
       if (finalScore > bestScore) {
         bestScore = finalScore;
@@ -2450,8 +2579,8 @@ function snapPointToClearancePeak(p, clearance, isWalkableCell, radius = 4) {
   }
   return best;
 }
-function centerlineSnapPath(path, clearance, isWalkableCell, radius = 4) {
-  const snapped = path.map((p) => snapPointToClearancePeak(p, clearance, isWalkableCell, radius));
+function centerlineSnapPath(path, clearanceGrid, isWalkableCell, radius = 4) {
+  const snapped = path.map((p) => snapPointToClearancePeak(p, clearanceGrid, isWalkableCell, radius));
   return snapped;
 }
 
@@ -2463,19 +2592,19 @@ function shortestPath(start, end, options) {
   let obstacles = options.obstacles || featureCollection([]);
   if (!start) throw new Error("start is required");
   if (!end) throw new Error("end is required");
-  if (resolution && !isNumber2(resolution) || resolution <= 0)
+  if (resolution && !isNumber(resolution) || resolution <= 0)
     throw new Error("options.resolution must be a number, greater than 0");
   const startCoord = (0, import_invariant2.getCoord)(start);
   const endCoord = (0, import_invariant2.getCoord)(end);
-  start = point2(startCoord);
-  end = point2(endCoord);
+  start = point(startCoord);
+  end = point(endCoord);
   switch ((0, import_invariant2.getType)(obstacles)) {
     case "FeatureCollection":
       if (obstacles.features.length === 0)
         return lineString([startCoord, endCoord]);
       break;
     case "Polygon":
-      obstacles = featureCollection([feature2((0, import_invariant2.getGeom)(obstacles))]);
+      obstacles = featureCollection([feature((0, import_invariant2.getGeom)(obstacles))]);
       break;
     default:
       throw new Error("invalid obstacles");
@@ -2484,15 +2613,15 @@ function shortestPath(start, end, options) {
   collection.features.push(start, end);
   const box = index_default((0, import_transform_scale.default)((0, import_bbox_polygon.default)(index_default(collection)), 1.15));
   if (!resolution) {
-    const width = (0, import_distance7.default)([box[0], box[1]], [box[2], box[1]], options);
+    const width = (0, import_distance8.default)([box[0], box[1]], [box[2], box[1]], options);
     resolution = width / 100;
   }
   collection.features.pop();
   collection.features.pop();
   const [west, south, east, north] = box;
-  const xFraction = resolution / (0, import_distance7.default)([west, south], [east, south], options);
+  const xFraction = resolution / (0, import_distance8.default)([west, south], [east, south], options);
   const cellWidth = xFraction * (east - west);
-  const yFraction = resolution / (0, import_distance7.default)([west, south], [west, north], options);
+  const yFraction = resolution / (0, import_distance8.default)([west, south], [west, north], options);
   const cellHeight = yFraction * (north - south);
   const bboxHorizontalSide = east - west;
   const bboxVerticalSide = north - south;
@@ -2522,16 +2651,16 @@ function shortestPath(start, end, options) {
     }
   }
   while (totalRounds--) {
-    pt = point2([currentX, currentY]);
-    isInsideObstacle = (0, import_boolean_point_in_polygon3.default)(pt, combinedObstacle);
-    (0, import_lodash17.set)(matrix, `[${row}][${column}]`, isInsideObstacle ? 1 : 0);
-    (0, import_lodash17.set)(pointMatrix, `[${row}][${column}]`, `${currentX}|${currentY}`);
-    distStart = (0, import_distance7.default)(pt, start);
+    pt = point([currentX, currentY]);
+    isInsideObstacle = (0, import_boolean_point_in_polygon4.default)(pt, combinedObstacle);
+    (0, import_lodash20.set)(matrix, `[${row}][${column}]`, isInsideObstacle ? 1 : 0);
+    (0, import_lodash20.set)(pointMatrix, `[${row}][${column}]`, `${currentX}|${currentY}`);
+    distStart = (0, import_distance8.default)(pt, start);
     if (!isInsideObstacle && distStart < minDistStart) {
       minDistStart = distStart;
       closestToStart = { x: column, y: row };
     }
-    distEnd = (0, import_distance7.default)(pt, end);
+    distEnd = (0, import_distance8.default)(pt, end);
     if (!isInsideObstacle && distEnd < minDistEnd) {
       minDistEnd = distEnd;
       closestToEnd = { x: column, y: row };
@@ -2562,9 +2691,6 @@ function shortestPath(start, end, options) {
     const clearanceGrid = buildClearanceGrid(matrix);
     const isWalkable = (x, y) => grid.isInside(x, y) && grid.isWalkableAt(x, y);
     result = centerlineSnapPath(result, clearanceGrid, isWalkable);
-    result = stringPull(grid, result);
-    result = pruneSmallAngles(result);
-    result = pruneShortSegments(result);
   }
   result.pop();
   result.shift();
@@ -2584,8 +2710,28 @@ var createWalkablePathService = (ctx, options) => {
   const { units = [], kiosks = [], fixtures = [] } = ctx.data;
   const possibleObstacleFeatures = [...units, ...kiosks, ...fixtures];
   const filterObstaclesByOrdinal = (levelId) => {
-    return possibleObstacleFeatures.filter(({ feature_type, properties, geometry }) => {
-      return properties.level_id === levelId && ["Polygon", "MultiPolygon"].includes(geometry.type) && (OBSTACLE_FEATURE_TYPES.includes(feature_type) || "category" in properties && OBSTACLE_CATEGORIES.includes(properties.category));
+    const OBSTACLE_FEATURETYPE_AND_CATEGORIES = [
+      "fixture.vegetation",
+      "fixture.water",
+      "fixture.stage",
+      "fixture.wall",
+      "kiosk",
+      "unit.nonpublic",
+      "unit.opentobelow",
+      "unit.elevator",
+      "unit.escalator",
+      "unit.stairs",
+      "unit.room",
+      "unit.unspecified",
+      "unit.structure",
+      "unit.brick",
+      "unit.concrete",
+      "unit.drywall",
+      "unit.column"
+    ];
+    return possibleObstacleFeatures.filter((f) => f.properties.level_id === levelId).filter(({ feature_type, properties }) => {
+      const featureTypeAndCat = `${feature_type}${"category" in properties ? `.${properties.category}` : ``}`;
+      return OBSTACLE_FEATURETYPE_AND_CATEGORIES.includes(featureTypeAndCat);
     });
   };
   const findObstaclesFromWalkway = (intermediaryUnit, exceptionIds = []) => {
@@ -2597,13 +2743,38 @@ var createWalkablePathService = (ctx, options) => {
     );
     const relatedObstacleWithIntermediary = obstacleOnLevel.reduce(
       (obstacles, feature3) => {
-        if (
-          // Prevent detecting itself as an obstacle
-          // Ex. Unable to draw a line to amenity located with in a room as room is also consider as obstacle
-          feature3.id !== intermediaryUnit.id && ((0, import_boolean_overlap.default)(intermediaryUnit, feature3) || (0, import_boolean_intersects.default)(intermediaryUnit, feature3))
-        ) {
-          const polygons = (0, import_invariant3.getType)(feature3) === "Polygon" ? [polygon(feature3.geometry.coordinates, { id: feature3.id })] : feature3.geometry.coordinates.map((ring) => polygon(ring, { id: feature3.id }));
-          obstacles.push(...polygons);
+        try {
+          if (
+            // Prevent detecting itself as an obstacle
+            // Ex. Unable to draw a line to amenity located with in a room as room is also consider as obstacle
+            feature3.id !== intermediaryUnit.id && (0, import_boolean_intersects.default)(intermediaryUnit, feature3)
+          ) {
+            const type = (0, import_invariant3.getType)(feature3);
+            switch (type) {
+              case "Polygon":
+                obstacles.push(feature3);
+                break;
+              case "MultiPolygon": {
+                feature3.geometry.coordinates.map((p) => {
+                  const f = polygon(p, { id: feature3.id });
+                  obstacles.push(f);
+                });
+                break;
+              }
+              case "LineString": {
+                obstacles.push((0, import_buffer.buffer)(feature3.geometry, 0.3, { units: "meters" }));
+                break;
+              }
+              case "MultiLineString": {
+                feature3.geometry.coordinates.map((line) => {
+                  const f = (0, import_buffer.buffer)(lineString(line), 0.3, { units: "meters" });
+                  obstacles.push(f);
+                });
+                break;
+              }
+            }
+          }
+        } catch (e) {
         }
         return obstacles;
       },
@@ -2627,14 +2798,13 @@ var createWalkablePathService = (ctx, options) => {
     return stepPath;
   };
   const findWalkablePath = (from, to, intermediaries) => {
-    const t0 = performance.now();
     const relatedWalkablePlatform = intermediaries.find(
-      (feature3) => WALKABLE_CATEGORY.includes(feature3.properties.category)
+      (feature3) => WALKABLE_UNIT_CATEGORY.includes(feature3.properties.category)
     );
     const exceptionFeatureIds = [];
     const obstacles = findObstaclesFromWalkway(
       relatedWalkablePlatform,
-      import_lodash18.default.compact(exceptionFeatureIds)
+      import_lodash21.default.compact(exceptionFeatureIds)
     );
     const line = findPathOnArea(from, to, {
       resolution,
@@ -2649,7 +2819,7 @@ var createWalkablePathService = (ctx, options) => {
 
 // src/data/navigate/services/steps/createStepService.ts
 var createStepService = (ctx) => {
-  const { data: { units, relationships }, findByIdSync, landmarkService } = ctx;
+  const { data: { units, occupants = [], relationships }, findByIdSync, landmarkService } = ctx;
   const walkablePathUtils = createWalkablePathService(ctx, { resolution: 88e-5 });
   const findUnitBetweenOpenings = (originId, destinationId) => {
     const origin = findByIdSync(originId);
@@ -2658,7 +2828,7 @@ var createStepService = (ctx) => {
     const matchOneUnits = matchedOne ? [matchedOne.properties.origin, matchedOne.properties.destination] : [];
     const matchedTwo = relationships.find((rel) => (rel.properties.intermediary || []).map((int) => int.id).includes(destination.id));
     const matchTwoUnits = matchedTwo ? [matchedTwo.properties.origin, matchedTwo.properties.destination] : [];
-    const unitIds = (0, import_lodash19.intersectionBy)(matchOneUnits, matchTwoUnits, "id");
+    const unitIds = (0, import_lodash22.intersectionBy)(matchOneUnits, matchTwoUnits, "id");
     return unitIds.map(({ id }) => findByIdSync(id));
   };
   const findHorizontalIntermediary = (from, to) => {
@@ -2674,7 +2844,7 @@ var createStepService = (ctx) => {
   };
   const getAdjacentUnitsByOpening = (openingId) => {
     const relationship = relationships.find((rel) => (rel.properties.intermediary || []).map((int) => int.id).includes(openingId));
-    const units2 = (0, import_lodash19.compact)([
+    const units2 = (0, import_lodash22.compact)([
       relationship?.properties.origin.id,
       relationship?.properties.destination.id
     ]).map((unitId) => findByIdSync(unitId));
@@ -2688,11 +2858,18 @@ var createStepService = (ctx) => {
     const verticalUnits = [...firstAdjacentUnits, ...secondAdjacentUnits].filter((unit) => VERTICAL_TRAVERSAL_CATEGORY.includes(unit.properties.category));
     return verticalUnits;
   };
+  const findOccupantForUnit = (unit) => {
+    return occupants.find(
+      (o) => o.properties.main_location === unit.id || (o.properties.correlated_locations ?? []).includes(unit.id)
+    );
+  };
   const createHorizontalStep = (from, to) => {
     const intermediary = findHorizontalIntermediary(from, to);
     const intermediaryCategories = intermediary.map((unit) => unit.properties.category);
-    const intermediaryCategory = intermediaryCategories.length > 0 ? intermediaryCategories[0] : "unspecified";
+    const intermediaryCategory = intermediaryCategories.length > 0 ? intermediaryCategories[0] ?? "unspecified" : "unspecified";
     const intermediaryIds = intermediary.map((unit) => unit.id);
+    const occupant = intermediary[0] ? findOccupantForUnit(intermediary[0]) : void 0;
+    const intermediaryName = occupant?.properties.name.en ?? intermediaryCategory;
     const toward = landmarkService.findTowardLandmark(from.point, to.point, to.ordinal);
     const nearBy = landmarkService.findNearestLandmark(to.point, to.ordinal);
     const path = walkablePathUtils.findWalkablePath(from.point, to.point, intermediary);
@@ -2704,9 +2881,9 @@ var createStepService = (ctx) => {
       intermediaryCategory,
       intermediaryIds,
       description: describeHorizontalStep(
-        intermediaryCategory,
-        toward ? toward.name : null,
-        nearBy ? nearBy.name : null
+        intermediaryName,
+        toward ? toward.name : void 0,
+        nearBy ? nearBy.name : void 0
       ),
       path: path.map((coord) => [...coord, from.ordinal * 9])
     };
@@ -2782,7 +2959,7 @@ var mergeStepsByOrdinal = (steps) => {
   let current = steps[0];
   for (let i = 1; i < steps.length; i++) {
     const next = steps[i];
-    if (arrayEqual(current.ordinals, next.ordinals)) {
+    if (arrayEqual(current.ordinals, next.ordinals) && !current.to.checkpoint) {
       current = mergeTwoSteps(current, next);
     } else {
       out.push(current);
@@ -2810,7 +2987,7 @@ var getNavigateClient = (options) => {
   const findCoordinateOrdinalLocatedUnit = (params, sourceUnits = units) => {
     const [lng, lat, ordinal] = parseOrdinalCoordinate(params);
     const levelIdsWithOrdinal = levels.filter((level) => level.properties.ordinal === ordinal).map((level) => level.id);
-    const unit = sourceUnits.find((unit2) => levelIdsWithOrdinal.includes(unit2.properties.level_id) && (0, import_boolean_point_in_polygon4.booleanPointInPolygon)([lng, lat], unit2));
+    const unit = sourceUnits.find((unit2) => levelIdsWithOrdinal.includes(unit2.properties.level_id) && (0, import_boolean_point_in_polygon5.booleanPointInPolygon)([lng, lat], unit2));
     return unit;
   };
   const findRoute = async (routeOriginParam, routeDestinationParam, options2) => {
@@ -2912,6 +3089,13 @@ var getSearchClient = ({ occupants, amenities }) => {
 };
 
 // src/data/getDataClient.ts
+var resolveFeatureTypeFromId = (id) => {
+  if (id === null || id === void 0) return null;
+  const featureType = id.split("-")[0];
+  const override = ID_PREFIX_TO_FEATURE_TYPE[featureType];
+  if (override) return override;
+  return featureType || null;
+};
 var getDataClient = (options) => {
   let searchClient;
   let navigateClient;
@@ -2944,7 +3128,11 @@ var getDataClient = (options) => {
   };
   const internalFindById = async (id) => {
     if (id === null || id === void 0) return null;
-    const featureType = id.slice(0, id.lastIndexOf("-"));
+    const featureType = resolveFeatureTypeFromId(id);
+    if (!featureType) {
+      console.warn(`[venue-js] Cannot resolve feature type from id "${id}"`);
+      return null;
+    }
     const feature3 = await queryClient.ensureQueryData({
       queryKey: ["_deliveryapi", featureType, id],
       queryFn: async () => {
@@ -2959,20 +3147,28 @@ var getDataClient = (options) => {
   };
   const populator = createPopulator({ internalFindById, internalFilterByType });
   const registerObserver = (featureType, refetchInterval) => {
-    if (observers.has(featureType)) {
-      console.warn(`Observer for ${featureType} already exists`);
-      const record = observers.get(featureType);
-      return record.observer;
+    const existing = observers.get(featureType);
+    if (existing) {
+      if (refetchInterval === existing.refetchInterval) {
+        return existing.observer;
+      } else if (refetchInterval > existing.refetchInterval) {
+        console.warn(`[venue-js] Observer for "${featureType}" not registered \u2014 existing observer already uses a smaller interval (${existing.refetchInterval}ms < ${refetchInterval}ms)`);
+        return existing.observer;
+      } else if (refetchInterval < existing.refetchInterval) {
+        console.warn(`[venue-js] Observer for "${featureType}" re-registering with smaller interval (${refetchInterval}ms < ${existing.refetchInterval}ms)`);
+        existing.unsubscribe();
+        observers.delete(featureType);
+      }
     }
     const options2 = createDeliveryApiQueryOptions(featureType);
     const observer = new import_query_core.QueryObserver(queryClient, {
       ...options2,
       refetchInterval
     });
+    console.log(`[venue-js] Listening to ${featureType} changes (interval = ${refetchInterval}ms)`);
     const unsubscribe = observer.subscribe(() => {
-      console.log(`[venue-js] Listening to ${featureType} changes (interval = ${refetchInterval}ms)`);
     });
-    observers.set(featureType, { observer, unsubscribe });
+    observers.set(featureType, { observer, unsubscribe, refetchInterval });
     return observer;
   };
   const destroyObserver = (featureType) => {
@@ -3039,7 +3235,7 @@ var getDataClient = (options) => {
   };
   const navigateFn = async (origin, destination, options2) => {
     if (!navigateClient) {
-      const [levels, occupants, openings, relationships, units, fixtures, kiosks, amenities, anchors] = await Promise.all([
+      const [levels, occupants, openings, relationships, units, fixtures, kiosks, amenities, anchors, sections] = await Promise.all([
         filterByType("level"),
         filterByType("occupant"),
         filterByType("opening"),
@@ -3048,9 +3244,10 @@ var getDataClient = (options) => {
         filterByType("fixture"),
         filterByType("kiosk"),
         filterByType("amenity"),
-        filterByType("anchor")
+        filterByType("anchor"),
+        filterByType("section")
       ]);
-      const haystack = { levels, occupants, openings, relationships, units, fixtures, kiosks, amenities, anchors };
+      const haystack = { levels, occupants, openings, relationships, units, fixtures, kiosks, amenities, anchors, sections };
       navigateClient = getNavigateClient({ data: haystack, unitDistanceOptions: options2?.unitDistanceOptions });
     }
     return navigateClient.findRoute(origin, destination, options2);
@@ -3075,6 +3272,7 @@ var getDataClient = (options) => {
   ALL_FEATURE_TYPES,
   DEFAULT_BASE_URL,
   GEOJSON_FEATURE_TYPES,
+  ID_PREFIX_TO_FEATURE_TYPE,
   IMDF_FEATURE_TYPES,
   IMDF_UNIT_CATEGORIES,
   NONIMDF_FEATURE_TYPES,
@@ -3101,6 +3299,7 @@ var getDataClient = (options) => {
   getDataClient,
   getInstructionText,
   getNavigateClient,
+  getPointOnFeature,
   getSearchClient,
   getTurn,
   matchFilter,