@mapvx/web-js 4.0.2 → 4.0.3-dev.2

package/dist/es/sdk.js

@@ -4,11 +4,6 @@ import { Loggeable } from "./domain/models/loggeable";
 import { InternalGetRouteConfiguration, } from "./domain/models/routeConfiguration";
 import { CacheManager } from "./infrastructure/cache/CacheManager";
 import { Repository } from "./repository/repository";
-/**
- * Normalize the argument accepted by the place-detail methods into a
- * {@link PlaceQuery}. A plain string is treated as the place id/alias with no
- * building/floor disambiguation, preserving backward compatibility.
- */
 function normalizePlaceQuery(place) {
     return typeof place === "string" ? { id: place } : place;
 }
@@ -27,16 +22,7 @@ export function initializeSDK(token, config) {
     const sdk = new InternalMapVXSDK(token, sdkConfig);
     return sdk;
 }
-/**
- * Main class to access the SDK functionalities.
- * @category Main
- */
 export class InternalMapVXSDK extends Loggeable {
-    /**
-     * Create a new MapVXSDK object.
-     * @param token The secret API token that you obtained from MapVX.
-     * @param config Configuration object for SDK customization
-     */
     constructor(token, config) {
         var _a, _b, _c;
         super();
@@ -45,7 +31,6 @@ export class InternalMapVXSDK extends Loggeable {
         this.headingListeners = [];
         this.token = token;
         this.config = config;
-        // Create cache manager with user configuration
         const cacheManager = new CacheManager({
             persistent: (_a = config.cache) === null || _a === void 0 ? void 0 : _a.persistent,
             maxStorageBytes: (_b = config.cache) === null || _b === void 0 ? void 0 : _b.maxStorageBytes,
@@ -60,12 +45,8 @@ export class InternalMapVXSDK extends Loggeable {
         this.cachePlaces();
         this.logEvent("initSDK");
     }
-    /**
-     * Fetch and save on cache the data from the available places.
-     */
     cachePlaces() {
         this.repository.fetchAndParseAvailablePlaces().catch(() => {
-            // Error already logged in repository
         });
     }
     setSdkLang(lang) {
@@ -110,9 +91,6 @@ export class InternalMapVXSDK extends Loggeable {
             mapConfig.apiUrl = this.config.apiUrl;
             mapConfig.portalApiUrl = this.config.portalApiUrl;
             mapConfig.mapvxRequestContext = this.config.mapvxRequestContext;
-            // Routing endpoints go through the map's own Repository, so forward the
-            // (possibly overridden) hosts too — otherwise routes would fall back to
-            // the hardcoded api.mapvx.com even when the SDK was pointed at an edge.
             mapConfig.routeApiUrl = this.config.routeApiUrl;
             mapConfig.healthApiUrl = this.config.healthApiUrl;
             mapConfig.legacyApiUrl = this.config.legacyApiUrl;
@@ -268,7 +246,6 @@ export class InternalMapVXSDK extends Loggeable {
     }
     async getPlacesByInput(input, institutionId, parentPlaceId, otherParentPlacesIds, origin, lat, lng, floor) {
         try {
-            // TODO: se debe cambiar a usar un solo parámetro en la siguiente version major.
             const parentPlaces = parentPlaceId
                 ? otherParentPlacesIds
                     ? [parentPlaceId, ...otherParentPlacesIds]
@@ -308,8 +285,6 @@ export class InternalMapVXSDK extends Loggeable {
     }
     async getPlacesByCategory(category) {
         try {
-            // TODO: Implement proper category-based search when API endpoint is available
-            // For now, return an empty array as a placeholder implementation
             this.logEvent("getPlacesByCategory");
             return [];
         }
@@ -354,11 +329,9 @@ export class InternalMapVXSDK extends Loggeable {
             }
             let heading = null;
             if (event.webkitCompassHeading !== undefined) {
-                // Para iOS
                 heading = event.webkitCompassHeading || null;
             }
             else if (event.absolute && event.alpha !== null) {
-                // Para Android y otros navegadores
                 heading = 360 - event.alpha;
             }
             if (heading !== null) {
@@ -370,22 +343,15 @@ export class InternalMapVXSDK extends Loggeable {
         };
         this.headingListeners.push(listener);
         if ("ondeviceorientationabsolute" in window) {
-            // We can listen for the new deviceorientationabsolute event.
             window.addEventListener("deviceorientationabsolute", listener);
         }
         else if ("ondeviceorientation" in window) {
-            // We can still listen for deviceorientation events.
-            // The `absolute` property of the event tells us whether
-            // or not the degrees are absolute.
             const w = window;
             w.addEventListener("deviceorientation", listener);
         }
     }
     unwatchUserHeading() {
         this.headingListeners.forEach((listener) => {
-            // It is safe to call with both events
-            // since the call with the event that has no listener
-            // will simply do nothing.
             window.removeEventListener("deviceorientationabsolute", listener);
             window.removeEventListener("deviceorientation", listener);
         });
@@ -430,4 +396,3 @@ export class InternalMapVXSDK extends Loggeable {
         }
     }
 }
-//# sourceMappingURL=sdk.js.map

package/dist/es/utils/3d.d.ts

@@ -125,4 +125,3 @@ export declare function computeScenePosition(target: {
     x: number;
     y: number;
 }, meterScale: number, assetOffset?: GLBModelOffset, placementOffset?: GLBModelOffset): [number, number, number];
-//# sourceMappingURL=3d.d.ts.map

package/dist/es/utils/3d.js

@@ -1,9 +1,4 @@
-/** Default LOD hysteresis (zoom units) when {@link Models3DLodConfig.hysteresis} is unset. */
 export const DEFAULT_LOD_HYSTERESIS = 0.5;
-/**
- * Computes the unload/reload zoom boundaries from {@link Models3DConfig.lod}, or `null` when LOD is
- * disabled (no `lod`, no models, or a non-finite `minZoom`). Pure — safe to unit-test without WebGL.
- */
 export const resolveModels3DLodThresholds = (models) => {
     const lod = models === null || models === void 0 ? void 0 : models.lod;
     if (!models ||
@@ -21,12 +16,6 @@ export const resolveModels3DLodThresholds = (models) => {
         unloadBelow: lod.minZoom - hysteresis,
     };
 };
-/**
- * Decides what the LOD controller should do at the current zoom given whether the models are
- * currently unloaded. Returns `"unload"` when they are loaded but the camera is below the unload
- * boundary, `"reload"` when they are unloaded but the camera has returned to/above the reload
- * boundary, and `"none"` otherwise (including within the hysteresis band). Pure/testable.
- */
 export const lodActionForZoom = (zoom, thresholds, currentlyUnloaded) => {
     if (!currentlyUnloaded && zoom < thresholds.unloadBelow) {
         return "unload";
@@ -36,28 +25,12 @@ export const lodActionForZoom = (zoom, thresholds, currentlyUnloaded) => {
     }
     return "none";
 };
-/**
- * Conservative defaults that bound each deck.gl overlay layer's in-memory tile cache. Chosen to
- * favor low RAM: only the visible working set (plus a small margin) stays parsed in memory; the
- * raw tile bytes remain on disk in the Service Worker cache, so an evicted tile is re-parsed
- * rather than re-downloaded. Raise `maxCacheSize` only if profiling shows flashing at the
- * viewport edge while panning.
- * @internal
- */
 export const DEFAULT_DECK_TILE_CACHE = {
-    // Per layer; with four overlay layers this caps the parsed-tile set at ~4x this number.
     maxCacheSize: 64,
     maxRequests: 6,
-    // Drop parent tiles once children cover the viewport — keeps the resident set smallest.
     refinementStrategy: "no-overlap",
-    // Byte budget is opt-in (deck.gl only enforces it when a tile's byte size is known).
     maxCacheByteSize: undefined,
 };
-/**
- * Merges an optional {@link DeckTileCacheConfig} over {@link DEFAULT_DECK_TILE_CACHE}, ignoring
- * `undefined`/`null` fields and clamping numeric bounds to at least 1. The result is always
- * bounded — passing `undefined` yields the defaults, never an unlimited cache.
- */
 export const resolveDeckTileCache = (config) => {
     var _a;
     const clampPositive = (value, fallback) => typeof value === "number" && Number.isFinite(value) && value >= 1 ? Math.floor(value) : fallback;
@@ -73,10 +46,6 @@ export const resolveDeckTileCache = (config) => {
         maxCacheByteSize,
     };
 };
-/**
- * Default lights matching the legacy escalator scene when {@link Models3DConfig.lights} is unset.
- * @internal
- */
 export const DEFAULT_SCENE3D_LIGHTS = [
     { type: "directional", color: 0xffffff, intensity: 2, position: { x: 50, y: 100, z: 80 } },
     { type: "directional", color: 0xffffff, intensity: 1.5, position: { x: -50, y: 80, z: -60 } },
@@ -103,18 +72,12 @@ export const hexToRgba = (hex) => {
     const a = matches.length >= 4 ? Number.parseInt(matches[3], 16) : 255;
     return [r, g, b, a];
 };
-/**
- * Resolves lights for the declarative GLB scene: {@link Models3DConfig.lights} when set, otherwise SDK defaults.
- */
 export function resolveModels3DLights(models) {
     if (models.lights && models.lights.length > 0) {
         return [...models.lights];
     }
     return [...DEFAULT_SCENE3D_LIGHTS];
 }
-/**
- * Merges two partial rotations by adding each axis in degrees.
- */
 export function mergeRotation3D(a, b) {
     var _a, _b, _c, _d, _e, _f;
     return {
@@ -123,9 +86,6 @@ export function mergeRotation3D(a, b) {
         roll: ((_e = a === null || a === void 0 ? void 0 : a.roll) !== null && _e !== void 0 ? _e : 0) + ((_f = b === null || b === void 0 ? void 0 : b.roll) !== null && _f !== void 0 ? _f : 0),
     };
 }
-/**
- * Normalizes a uniform or per-axis scale; undefined uses `fallback` on all axes.
- */
 export function normalizeScale(scale, fallback) {
     if (scale === undefined) {
         return [fallback, fallback, fallback];
@@ -135,9 +95,6 @@ export function normalizeScale(scale, fallback) {
     }
     return [scale[0], scale[1], scale[2]];
 }
-/**
- * Placement scale overrides asset default when provided; otherwise asset (or 1) applies.
- */
 export function mergeGlbScale(assetDefault, placementOverride) {
     const base = normalizeScale(assetDefault, 1);
     if (placementOverride === undefined) {
@@ -145,72 +102,37 @@ export function mergeGlbScale(assetDefault, placementOverride) {
     }
     return normalizeScale(placementOverride, 1);
 }
-/**
- * Resolves the effective zoom-based transparency for a placement, applying precedence:
- * placement > asset > global. Returns `undefined` when none is configured.
- */
 export function resolveZoomTransparency(models, asset, placement) {
     var _a, _b;
     return (_b = (_a = placement.zoomTransparency) !== null && _a !== void 0 ? _a : asset === null || asset === void 0 ? void 0 : asset.zoomTransparency) !== null && _b !== void 0 ? _b : models.zoomTransparency;
 }
-/**
- * Opacity for a given zoom under a hard-threshold {@link ZoomTransparencyConfig}.
- * Returns `cfg.opacity` when `zoom >= cfg.zoom`, otherwise `1` (fully opaque).
- * With no config, returns `1`.
- */
 export function opacityForZoom(cfg, zoom) {
     if (!cfg) {
         return 1;
     }
     return zoom >= cfg.zoom ? cfg.opacity : 1;
 }
-/**
- * Resolves the effective route-based transparency for a placement, applying precedence:
- * placement > asset > global. Returns `undefined` when none is configured, which disables
- * route transparency for that model (a route crossing it leaves its opacity unchanged).
- */
 export function resolveRouteTransparency(models, asset, placement) {
     var _a, _b;
     return (_b = (_a = placement.routeTransparency) !== null && _a !== void 0 ? _a : asset === null || asset === void 0 ? void 0 : asset.routeTransparency) !== null && _b !== void 0 ? _b : models.routeTransparency;
 }
-/**
- * Whether a point already expressed in the model's local space falls within its x/z footprint.
- * @internal
- */
 export function pointInFootprint(footprint, localX, localZ) {
     return (localX >= footprint.minX &&
         localX <= footprint.maxX &&
         localZ >= footprint.minZ &&
         localZ <= footprint.maxZ);
 }
-/**
- * Effective opacity for a placed model: the more transparent of its zoom-based value and, when a
- * route currently crosses it, its route-based value. Route transparency only participates when a
- * {@link RouteTransparencyConfig} is configured (`routeCfg` present) and the model is currently
- * crossed by a route (`routeAffected`).
- * @internal
- */
 export function effectiveModelOpacity(zoomCfg, routeCfg, zoom, routeAffected) {
     const zoomOpacity = opacityForZoom(zoomCfg, zoom);
     const routeOpacity = routeAffected && routeCfg ? routeCfg.opacity : 1;
     return Math.min(zoomOpacity, routeOpacity);
 }
-/**
- * Whether a GLB placement should be visible for the given floor key.
- */
 export function isPlacementVisibleOnFloor(placement, floorKey) {
     if (placement.visibility.mode === "allFloors") {
         return true;
     }
     return placement.visibility.floorKey === floorKey;
 }
-/**
- * Computes a GLB pivot's scene-space position (in metres) from a placement's Mercator target and a
- * Mercator reference origin, plus the asset-level and placement-level offsets.
- *
- * X/Z come from the Mercator delta divided by the metre scale; Y comes only from the offsets (the
- * model is bottom-aligned separately). All offsets are in map-space metres.
- */
 export function computeScenePosition(target, ref, meterScale, assetOffset, placementOffset) {
     var _a, _b, _c, _d, _e, _f;
     const sx = (target.x - ref.x) / meterScale;
@@ -223,4 +145,3 @@ export function computeScenePosition(target, ref, meterScale, assetOffset, place
     const pz = (_f = placementOffset === null || placementOffset === void 0 ? void 0 : placementOffset.z) !== null && _f !== void 0 ? _f : 0;
     return [sx + ax + px, ay + py, sz + az + pz];
 }
-//# sourceMappingURL=3d.js.map

package/dist/es/utils/deckLayers.d.ts

@@ -48,4 +48,3 @@ export declare function buildStoreLogoData(features: Feature[], floorKey: string
  * per-logo scale factor. Returns a fallback of `10` when the icon is missing from the sprite atlas.
  */
 export declare function computeStoreLogoSize(mapping: Record<string, SpriteIconData>, icon: string, logoScale: Record<string, number>): number;
-//# sourceMappingURL=deckLayers.d.ts.map

package/dist/es/utils/deckLayers.js

@@ -1,13 +1,3 @@
-/**
- * Pure data builders for the deck.gl indoor overlay sublayers.
- *
- * These functions contain the feature-filtering and coordinate/height mapping logic used inside the
- * deck.gl `renderSubLayers` callbacks in {@link InternalMapVXMap}. They are kept free of any deck.gl
- * / WebGL imports so the logic is unit-testable without a GL context.
- *
- * @group Utils
- */
-/** Extracts polygon coordinate rings from a GeoJSON geometry (Polygon or MultiPolygon). */
 export function extractPolygonRings(geom) {
     if (geom.type === "Polygon") {
         return [geom.coordinates];
@@ -17,10 +7,6 @@ export function extractPolygonRings(geom) {
     }
     return [];
 }
-/**
- * Builds elevated room-outline paths from indoor "room" features on the given floor.
- * Each ring is lifted to `z` (feature `height` when present, otherwise `defaultHeight`).
- */
 export function buildElevatedPaths(features, floorKey, defaultHeight) {
     var _a;
     const rooms = features.filter((f) => {
@@ -40,10 +26,6 @@ export function buildElevatedPaths(features, floorKey, defaultHeight) {
     }
     return paths;
 }
-/**
- * Builds indoor label text data from `area_name` / `poi` point features on the given floor.
- * A feature is skipped when a matching `logo-{name}` sprite exists (icon takes priority over text).
- */
 export function buildLabelData(features, floorKey, hasImage, defaultHeight) {
     const labelFeatures = features.filter((f) => {
         var _a, _b, _c, _d, _e, _f;
@@ -57,7 +39,7 @@ export function buildLabelData(features, floorKey, hasImage, defaultHeight) {
         if (((_f = f.properties) === null || _f === void 0 ? void 0 : _f.floor_key) && f.properties.floor_key !== floorKey)
             return false;
         if (hasImage("logo-" + name))
-            return false; // icon has priority
+            return false;
         return true;
     });
     return labelFeatures.map((f) => {
@@ -71,7 +53,6 @@ export function buildLabelData(features, floorKey, hasImage, defaultHeight) {
         });
     });
 }
-/** Resolves the POI icon id from a feature's `tags` and `subclass`. */
 export function resolvePoiIcon(tags, subclass) {
     if (tags.includes("wheelchair"))
         return "accessible_toilets";
@@ -79,7 +60,6 @@ export function resolvePoiIcon(tags, subclass) {
         return "changing_table";
     return subclass;
 }
-/** Builds POI icon data (elevators / toilets) from point features on the given floor. */
 export function buildPoiIconData(features, floorKey, defaultHeight) {
     const poi = features.filter((f) => {
         var _a, _b, _c;
@@ -101,7 +81,6 @@ export function buildPoiIconData(features, floorKey, defaultHeight) {
         });
     });
 }
-/** Builds store-logo icon data from point features that have a matching `logo-{name}` sprite. */
 export function buildStoreLogoData(features, floorKey, spriteMapping, defaultHeight) {
     const logos = features.filter((f) => {
         var _a, _b, _c;
@@ -127,10 +106,6 @@ export function buildStoreLogoData(features, floorKey, spriteMapping, defaultHei
         };
     });
 }
-/**
- * Computes the display size for a store-logo icon from its sprite dimensions and an optional
- * per-logo scale factor. Returns a fallback of `10` when the icon is missing from the sprite atlas.
- */
 export function computeStoreLogoSize(mapping, icon, logoScale) {
     const m = mapping[icon];
     if (!m)
@@ -141,4 +116,3 @@ export function computeStoreLogoSize(mapping, icon, logoScale) {
     const base = 10 * (h / Math.max(w, h));
     return base * (logoScale[icon] || 1);
 }
-//# sourceMappingURL=deckLayers.js.map

package/dist/es/utils/error.d.ts

@@ -5,4 +5,3 @@
  * @returns An Error object.
  */
 export declare function convertToError(error: unknown): Error;
-//# sourceMappingURL=error.d.ts.map

package/dist/es/utils/error.js

@@ -1,9 +1,3 @@
-/**
- * Convert an unknown error to an Error object.
- * @group Utils
- * @param error - The unknown error.
- * @returns An Error object.
- */
 export function convertToError(error) {
     if (error instanceof Error) {
         return error;
@@ -13,4 +7,3 @@ export function convertToError(error) {
         return new Error(text);
     }
 }
-//# sourceMappingURL=error.js.map

package/dist/es/utils/images.d.ts

@@ -5,4 +5,3 @@
  * @returns A promise that resolves to the data URL of the image.
  */
 export declare function loadImageAsDataUrl(imgUrl: string): Promise<string>;
-//# sourceMappingURL=images.d.ts.map

package/dist/es/utils/images.js

@@ -1,9 +1,3 @@
-/**
- * Load an image as a data URL.
- * @group Utils
- * @param imgUrl - The URL of the image to load.
- * @returns A promise that resolves to the data URL of the image.
- */
 export function loadImageAsDataUrl(imgUrl) {
     return new Promise((resolve, reject) => {
         fetch(imgUrl)
@@ -19,4 +13,3 @@ export function loadImageAsDataUrl(imgUrl) {
             .catch(reject);
     });
 }
-//# sourceMappingURL=images.js.map

package/dist/es/utils/loadGlb.d.ts

@@ -88,4 +88,3 @@ export interface LoadGlbRootOptions {
  * @group Utils
  */
 export declare function loadGlbRoot(url: string, options?: LoadGlbRootOptions): Promise<THREE.Group>;
-//# sourceMappingURL=loadGlb.d.ts.map

package/dist/es/utils/loadGlb.js

@@ -1,26 +1,7 @@
 import { DEFAULT_DRACO_DECODER_PATH, DEFAULT_KTX2_TRANSCODER_PATH } from "../config/draco";
 import { loadMeshoptDecoder, loadThree, memoizeImport } from "./three";
-/**
- * Builds a stand-in meshopt decoder that defers importing the real module (and instantiating its
- * WASM) until the first `EXT_meshopt_compression` buffer actually needs decoding. GLBs without the
- * extension never trigger the import, so the decoder stays off the critical path of the first 3D
- * frame — it used to be part of the eager three.js import chain, delaying every scene load.
- *
- * `supported` mirrors the real module's own gate — it returns a bare `{ supported: false }` when
- * `typeof WebAssembly !== "object"` — so the answer is reproduced synchronously here without
- * importing anything. Reporting a flat `true` instead would break the platforms it claims to
- * support: `GLTFLoader` reads `supported` before deciding to decode, and on `false` with meshopt
- * merely OPTIONAL it returns `null` and falls back to the GLB's uncompressed buffer
- * (`GLTFLoader.js` `GLTFMeshoptCompression.loadBufferView`). Claiming support on a WASM-less
- * platform discards that fallback and fails the whole asset with a `TypeError` from this shim,
- * since `decodeGltfBufferAsync` does not exist on the real module there.
- *
- * @param load Injectable module loader, for tests. Defaults to the cached {@link loadMeshoptDecoder}.
- * @internal
- */
 export function createLazyMeshoptDecoder(load = loadMeshoptDecoder) {
     return {
-        // Same condition the real decoder uses, evaluated without loading it.
         supported: typeof WebAssembly === "object",
         decodeGltfBufferAsync: async (count, size, source, mode, filter) => {
             const decoder = await load();
@@ -29,20 +10,6 @@ export function createLazyMeshoptDecoder(load = loadMeshoptDecoder) {
         },
     };
 }
-/**
- * Lazily-initialized, cached GLTF loader configured with Draco + KTX2 support.
- *
- * The loaders (and their WebGLRenderer for KTX2 support detection) are heavy and pull in Three.js,
- * so they are created on first use inside the dynamic-import boundary rather than at module load.
- *
- * Memoized through {@link memoizeImport} for the same reason the loaders in `three.ts` are: a plain
- * `cached ??=` also caches a rejection. Fixing the three loaders was not enough, because this is a
- * SECOND cache wrapped around `loadThree()` — so a transient failure was evicted there and then
- * replayed from here forever, and `loadGlbRoot` awaits both, meaning every GLB kept failing with
- * the stale error long after `loadThree()` had recovered. Not only network: the `.then` below
- * constructs a `WebGLRenderer` for KTX2 support detection, and a failed context creation was
- * cached just the same.
- */
 const getGltfLoader = memoizeImport(() => loadThree().then((mod) => {
     const dracoLoader = new mod.DRACOLoader();
     dracoLoader.setDecoderPath(DEFAULT_DRACO_DECODER_PATH);
@@ -52,81 +19,25 @@ const getGltfLoader = memoizeImport(() => loadThree().then((mod) => {
     ktx2Loader.setTranscoderPath(DEFAULT_KTX2_TRANSCODER_PATH);
     gltfLoader.setKTX2Loader(ktx2Loader);
     ktx2Loader.detectSupport(new mod.THREE.WebGLRenderer({ antialias: true }));
-    // Enable EXT_meshopt_compression so meshopt-compressed GLBs decode, without paying for the
-    // decoder module up front: the lazy stand-in imports it (and instantiates its WASM) only when
-    // the first meshopt-compressed buffer is actually decoded. Assets that don't use the extension
-    // never load it. The cast is safe — with `decodeGltfBufferAsync` present, GLTFLoader touches
-    // only `supported` and `decodeGltfBufferAsync` (see LazyMeshoptDecoder).
     gltfLoader.setMeshoptDecoder(createLazyMeshoptDecoder());
     return gltfLoader;
 }));
-/**
- * Default per-asset timeout for {@link loadGlbRoot}.
- *
- * Guards against loaders that hang instead of throwing — a GLB whose binary chunk is truncated
- * (see {@link loadGlbRoot}'s completeness check) or otherwise malformed can put Three.js's
- * `DRACOLoader` into an undefined state: sometimes a decode error, sometimes no callback at all.
- * Without a timeout, one such asset never settles and blocks every other load queued behind it.
- *
- * Declarative GLB scenes can legitimately include very large assets — a client's ground-mesh
- * "Suelo" model measured at ~400 MB took ~26s to download alone on a solid connection, before any
- * Draco decode time, and totem hardware/networks in the field are often slower than that. The
- * timeout only needs to be long enough that no realistically-sized valid asset ever hits it; a
- * truly hung load (the actual failure this guards against) would still hang forever whether this
- * is 30 seconds or 500 seconds, so there is no tradeoff in keeping it generous.
- *
- * @group Configuration
- */
 export const DEFAULT_GLB_LOAD_TIMEOUT_MS = 500000;
-/**
- * Magic number ("glTF" read little-endian) at byte offset 0 of every binary glTF (`.glb`)
- * container. Used only to tell a binary GLB apart from a plain JSON `.gltf` payload — the latter
- * has no such header and skips the completeness check in {@link assertGlbBufferComplete}.
- */
 const GLB_MAGIC = 0x46546c67;
-/**
- * Rejects a GLB download that was cut short before it reaches Three.js's `GLTFLoader`/`DRACOLoader`,
- * whose behavior on truncated input ranges from a cryptic decode error (e.g. "Unexpected geometry
- * type") to an outright hang, rather than a clear message pointing at the actual problem.
- *
- * The binary glTF container format requires the 12-byte header's declared total length to equal
- * the file's real byte length (see the {@link https://registry.khronos.org/glTF/specs/2.0/glTF-2.0.html#binary-header | spec}).
- * A mismatch means the response body was truncated — a dropped connection, or the object stored at
- * `url` is itself incomplete — so every buffer-view offset past that point reads garbage. This is
- * exactly what was found in the field for one "Suelo" asset that both threw a decode error and (in
- * a larger sibling file) hung: the file's own header declared a ~383 MB binary chunk while only
- * ~8.7 MB had actually been received.
- */
 function assertGlbBufferComplete(buffer, url) {
     if (buffer.byteLength < 12)
-        return; // too short to have a GLB header; let parse() report it
+        return;
     const header = new DataView(buffer, 0, 12);
     if (header.getUint32(0, true) !== GLB_MAGIC)
-        return; // plain JSON .gltf, not a binary .glb
+        return;
     const declaredLength = header.getUint32(8, true);
     if (declaredLength !== buffer.byteLength) {
         throw new Error(`GLB download is truncated or corrupt: header declares ${declaredLength} bytes, received ${buffer.byteLength}: ${url}`);
     }
 }
-/**
- * Loads a GLB/GLTF from URL and returns the root scene group.
- * Central entry point so the loader implementation can be swapped later (e.g. Draco, KTX2, custom fetch).
- *
- * Fetches the raw bytes itself (rather than deferring to `GLTFLoader.load`) so a truncated download
- * can be caught and rejected clearly — see {@link assertGlbBufferComplete} — before it ever reaches
- * the Draco/KTX2 decoders.
- *
- * @param url - GLB URL
- * @returns Root `THREE.Group` from the loaded glTF scene
- * @group Utils
- */
 export async function loadGlbRoot(url, options = {}) {
     const { timeoutMs = DEFAULT_GLB_LOAD_TIMEOUT_MS, onProgress } = options;
     const [gltfLoader, { THREE: three }] = await Promise.all([getGltfLoader(), loadThree()]);
-    // Set once the caller has stopped waiting (success, failure, or timeout) so any callback three
-    // fires afterwards — e.g. a timed-out fetch/decode that keeps running in the background — is a
-    // no-op instead of resolving/rejecting an already-settled promise or emitting a stray progress
-    // event after the batch this asset belongs to already reported `done: true`.
     let settled = false;
     const fileLoader = new three.FileLoader();
     fileLoader.setResponseType("arraybuffer");
@@ -175,11 +86,6 @@ export async function loadGlbRoot(url, options = {}) {
     finally {
         settled = true;
         clearTimeout(timer);
-        // Cancels the underlying fetch (and, by never delivering its buffer, the Draco/KTX2 decode)
-        // so a timed-out asset actually frees its network/CPU usage instead of running to completion
-        // unattended — otherwise GLB_LOAD_CONCURRENCY only bounds how many loads the caller awaits,
-        // not how many are truly in flight. A no-op if `load` already won the race.
         fileLoader.abort();
     }
 }
-//# sourceMappingURL=loadGlb.js.map

package/dist/es/utils/mapvxHostname.d.ts

@@ -9,4 +9,3 @@
  * @group Utils
  */
 export declare function isMapVxRequestHostname(hostname: string): boolean;
-//# sourceMappingURL=mapvxHostname.d.ts.map

package/dist/es/utils/mapvxHostname.js

@@ -1,13 +1,3 @@
-/**
- * Returns whether a URL hostname is part of the MapVX API domain tree.
- * Matches `mapvx.com` and `mapvx.dev` plus any subdomain (`api.mapvx.com`,
- * `public-api.mapvx.com`, `api.mapvx.dev`, `portal.mapvx.dev`, etc.).
- * Does not match lookalike domains (e.g. `notmapvx.com`).
- *
- * @param hostname - Value from `URL.hostname` (no port)
- * @returns True if context headers should be attached for this host
- * @group Utils
- */
 export function isMapVxRequestHostname(hostname) {
     const h = hostname.trim().toLowerCase();
     if (!h) {
@@ -15,4 +5,3 @@ export function isMapVxRequestHostname(hostname) {
     }
     return /^(?:[a-z0-9-]+\.)*mapvx\.(?:com|dev)$/.test(h);
 }
-//# sourceMappingURL=mapvxHostname.js.map

package/dist/es/utils/nav-functions.d.ts

@@ -82,4 +82,3 @@ export declare abstract class NavFunctions {
      */
     static intermediateAngleBetween(initialAngle: number, finalAngle: number, fraction: number): number;
 }
-//# sourceMappingURL=nav-functions.d.ts.map